@tailor-platform/erp-kit 0.0.1 → 0.1.1

package/dist/cli.js

@@ -0,0 +1,914 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { z as z2 } from "zod";
+import { defineCommand as defineCommand2, runMain, arg as arg2 } from "politty";
+
+// src/mdschema.ts
+import path from "path";
+import fs from "fs";
+import { execFile } from "child_process";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function getMdschemaBin() {
+  const pkgPath = require2.resolve("@jackchuka/mdschema/package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.mdschema;
+  if (!bin) {
+    throw new Error("Could not resolve mdschema binary from package.json bin field");
+  }
+  return path.join(path.dirname(pkgPath), bin);
+}
+function runMdschema(args, cwd2) {
+  return new Promise((resolve4) => {
+    execFile(
+      getMdschemaBin(),
+      args,
+      { encoding: "utf-8", cwd: cwd2, timeout: 3e4 },
+      (error, stdout, stderr) => {
+        if (error) {
+          const execError = error;
+          resolve4({
+            exitCode: execError.code === "ENOENT" ? 127 : execError.status ?? 1,
+            stdout: stdout ?? "",
+            stderr: stderr ?? ""
+          });
+        } else {
+          resolve4({ exitCode: 0, stdout: stdout ?? "", stderr: stderr ?? "" });
+        }
+      }
+    );
+  });
+}
+
+// src/schemas.ts
+import path3 from "path";
+
+// src/util.ts
+import path2 from "path";
+var PACKAGE_ROOT = path2.resolve(import.meta.dirname, "..");
+
+// src/schemas.ts
+var SCHEMAS_ROOT = path3.join(PACKAGE_ROOT, "schemas");
+var MODULE_SCHEMAS = {
+  module: path3.join(SCHEMAS_ROOT, "module", "module.yml"),
+  command: path3.join(SCHEMAS_ROOT, "module", "command.yml"),
+  model: path3.join(SCHEMAS_ROOT, "module", "model.yml"),
+  feature: path3.join(SCHEMAS_ROOT, "module", "feature.yml")
+};
+var APP_COMPOSE_SCHEMAS = {
+  requirements: path3.join(SCHEMAS_ROOT, "app-compose", "requirements.yml"),
+  actors: path3.join(SCHEMAS_ROOT, "app-compose", "actors.yml"),
+  "business-flow": path3.join(SCHEMAS_ROOT, "app-compose", "business-flow.yml"),
+  story: path3.join(SCHEMAS_ROOT, "app-compose", "story.yml"),
+  screen: path3.join(SCHEMAS_ROOT, "app-compose", "screen.yml"),
+  resolver: path3.join(SCHEMAS_ROOT, "app-compose", "resolver.yml")
+};
+var ALL_SCHEMAS = {
+  ...MODULE_SCHEMAS,
+  ...APP_COMPOSE_SCHEMAS
+};
+
+// src/commands/check.ts
+function buildCheckTargets(config) {
+  const targets = [];
+  if (config.modulesRoot) {
+    const m = config.modulesRoot;
+    targets.push(
+      { glob: `${m}/[a-zA-Z]*/docs/features/*.md`, schemaKey: "feature" },
+      { glob: `${m}/[a-zA-Z]*/docs/commands/*.md`, schemaKey: "command" },
+      { glob: `${m}/[a-zA-Z]*/docs/models/*.md`, schemaKey: "model" },
+      { glob: `${m}/[a-zA-Z]*/README.md`, schemaKey: "module" }
+    );
+  }
+  if (config.appRoot) {
+    const a = config.appRoot;
+    targets.push(
+      { glob: `${a}/[a-zA-Z]*/README.md`, schemaKey: "requirements" },
+      { glob: `${a}/[a-zA-Z]*/docs/actors/*.md`, schemaKey: "actors" },
+      { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/README.md`, schemaKey: "business-flow" },
+      { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/story/*.md`, schemaKey: "story" },
+      { glob: `${a}/[a-zA-Z]*/docs/screen/*.md`, schemaKey: "screen" },
+      { glob: `${a}/[a-zA-Z]*/docs/resolver/*.md`, schemaKey: "resolver" }
+    );
+  }
+  return targets;
+}
+async function runCheck(config, cwd2) {
+  const targets = buildCheckTargets(config);
+  const results = await Promise.all(
+    targets.map(async (target) => {
+      const schemaPath = ALL_SCHEMAS[target.schemaKey];
+      if (!schemaPath) {
+        console.error(`Unknown schema key: ${target.schemaKey}`);
+        return 2;
+      }
+      const { exitCode, stdout, stderr } = await runMdschema(
+        ["check", target.glob, "--schema", schemaPath],
+        cwd2
+      );
+      if (stdout.trim()) console.log(stdout);
+      if (stderr.trim()) console.error(stderr);
+      return exitCode;
+    })
+  );
+  if (results.includes(2)) return 2;
+  return results.some((code) => code !== 0) ? 1 : 0;
+}
+
+// src/commands/sync-check.ts
+import path4 from "path";
+import fg from "fast-glob";
+import chalk from "chalk";
+function moduleCategories(root) {
+  return [
+    {
+      name: "command",
+      sourcePattern: `${root}/*/command/*.ts`,
+      docPattern: `${root}/*/docs/commands/*.md`,
+      exclusions: [/\.test\.ts$/]
+    },
+    {
+      name: "model",
+      sourcePattern: `${root}/*/db/*.ts`,
+      docPattern: `${root}/*/docs/models/*.md`,
+      exclusions: [/\.test\.ts$/, /^index\.ts$/]
+    }
+  ];
+}
+function appComposeCategories(root) {
+  return [
+    {
+      name: "resolver",
+      sourcePattern: `${root}/*/backend/src/modules/**/resolvers/*.ts`,
+      docPattern: `${root}/*/docs/resolver/*.md`,
+      exclusions: [/\.test\.ts$/, /^index\.ts$/]
+    }
+  ];
+}
+function shouldExclude(fileName, exclusions) {
+  return exclusions.some((pattern) => pattern.test(fileName));
+}
+async function runSyncCheck(config, cwd2) {
+  const errors = [];
+  let totalSources = 0;
+  let totalDocs = 0;
+  const allCategories = [];
+  if (config.modulesRoot) {
+    allCategories.push(...moduleCategories(config.modulesRoot));
+  }
+  if (config.appRoot) {
+    allCategories.push(...appComposeCategories(config.appRoot));
+  }
+  for (const category of allCategories) {
+    const sources = await fg(category.sourcePattern, { cwd: cwd2 });
+    const docs = await fg(category.docPattern, { cwd: cwd2 });
+    const sourceBasenames = /* @__PURE__ */ new Map();
+    const docBasenames = /* @__PURE__ */ new Map();
+    for (const sourcePath of sources) {
+      const fileName = path4.basename(sourcePath);
+      if (shouldExclude(fileName, category.exclusions)) continue;
+      const basename2 = path4.basename(sourcePath, path4.extname(sourcePath));
+      sourceBasenames.set(basename2.toLowerCase(), sourcePath);
+    }
+    for (const docPath of docs) {
+      const basename2 = path4.basename(docPath, path4.extname(docPath));
+      docBasenames.set(basename2.toLowerCase(), docPath);
+    }
+    for (const [basename2, sourcePath] of sourceBasenames) {
+      if (!docBasenames.has(basename2)) {
+        errors.push({
+          type: "missing-doc",
+          category: category.name,
+          sourcePath,
+          expectedBasename: basename2
+        });
+      }
+    }
+    for (const [basename2, docPath] of docBasenames) {
+      if (!sourceBasenames.has(basename2)) {
+        errors.push({
+          type: "orphaned-doc",
+          category: category.name,
+          docPath,
+          expectedBasename: basename2
+        });
+      }
+    }
+    totalSources += sourceBasenames.size;
+    totalDocs += docBasenames.size;
+  }
+  return {
+    exitCode: errors.length > 0 ? 1 : 0,
+    errors,
+    summary: {
+      categoriesChecked: allCategories.length,
+      totalSources,
+      totalDocs
+    }
+  };
+}
+function formatSyncCheckReport(result) {
+  const lines = [];
+  lines.push(chalk.bold("docs-sync-check: Checking source-documentation correspondence...\n"));
+  if (result.errors.length > 0) {
+    lines.push(chalk.red.bold("Errors:\n"));
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const error of result.errors) {
+      const existing = byCategory.get(error.category) ?? [];
+      existing.push(error);
+      byCategory.set(error.category, existing);
+    }
+    for (const [category, categoryErrors] of byCategory) {
+      lines.push(chalk.cyan(`  Category: ${category}
+`));
+      for (const error of categoryErrors) {
+        if (error.type === "missing-doc") {
+          lines.push(`  ${chalk.red(error.sourcePath)}`);
+          lines.push(`    ${chalk.yellow("Missing documentation for:")} ${error.expectedBasename}`);
+        } else {
+          lines.push(`  ${chalk.red(error.docPath)}`);
+          lines.push(
+            `    ${chalk.yellow("Orphaned documentation:")} no source file for ${error.expectedBasename}`
+          );
+        }
+        lines.push("");
+      }
+    }
+  } else {
+    lines.push(chalk.green("All source files have corresponding documentation.\n"));
+  }
+  lines.push(chalk.bold("Summary:"));
+  lines.push(`  Categories checked: ${result.summary.categoriesChecked}`);
+  lines.push(
+    `  Source files: ${result.summary.totalSources}, Doc files: ${result.summary.totalDocs}`
+  );
+  if (result.errors.length > 0) {
+    lines.push(chalk.red(`  Errors: ${result.errors.length}`));
+    lines.push("");
+    lines.push(chalk.red.bold(`docs-sync-check failed with ${result.errors.length} error(s).`));
+  } else {
+    lines.push(chalk.green("  Errors: 0"));
+    lines.push("");
+    lines.push(chalk.green.bold("docs-sync-check passed."));
+  }
+  return lines.join("\n");
+}
+
+// src/commands/scaffold.ts
+import path5 from "path";
+import fs2 from "fs";
+var MODULE_TYPES = ["module", "feature", "command", "model"];
+var APP_TYPES = [
+  "requirements",
+  "actors",
+  "business-flow",
+  "story",
+  "screen",
+  "resolver"
+];
+var ALL_TYPES = [...MODULE_TYPES, ...APP_TYPES];
+var MODULE_DIR_MAP = {
+  feature: "docs/features",
+  command: "docs/commands",
+  model: "docs/models"
+};
+var APP_DIR_MAP = {
+  actors: "docs/actors",
+  "business-flow": "docs/business-flow",
+  screen: "docs/screen",
+  resolver: "docs/resolver"
+};
+function isModuleType(type) {
+  return MODULE_TYPES.includes(type);
+}
+function resolveScaffoldPath(type, parentName, name, root) {
+  if (type === "module" || type === "requirements") {
+    return path5.join(root, parentName, "README.md");
+  }
+  if (!name) {
+    throw new Error(`Name is required for scaffold type "${type}"`);
+  }
+  if (type === "business-flow") {
+    return path5.join(root, parentName, "docs/business-flow", name, "README.md");
+  }
+  if (type === "story") {
+    const parts = name.split("/");
+    if (parts.length !== 2) {
+      throw new Error(
+        `Story name must be "<flow>/<story>" (e.g., "onboarding/admin--create-user")`
+      );
+    }
+    return path5.join(root, parentName, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
+  }
+  if (MODULE_DIR_MAP[type]) {
+    return path5.join(root, parentName, MODULE_DIR_MAP[type], `${name}.md`);
+  }
+  if (APP_DIR_MAP[type]) {
+    return path5.join(root, parentName, APP_DIR_MAP[type], `${name}.md`);
+  }
+  throw new Error(`Unknown scaffold type: ${type}`);
+}
+async function runScaffold(type, parentName, name, root, cwd2) {
+  const outputPath = resolveScaffoldPath(type, parentName, name, root);
+  const absoluteOutput = path5.resolve(cwd2, outputPath);
+  if (fs2.existsSync(absoluteOutput)) {
+    console.error(`File already exists: ${outputPath}`);
+    return 1;
+  }
+  const schemaPath = ALL_SCHEMAS[type];
+  if (!schemaPath) {
+    console.error(`No schema found for type: ${type}`);
+    return 2;
+  }
+  try {
+    fs2.mkdirSync(path5.dirname(absoluteOutput), { recursive: true });
+  } catch (err) {
+    console.error(
+      `Failed to create directory: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return 1;
+  }
+  const { exitCode, stdout, stderr } = await runMdschema(
+    ["generate", "--schema", schemaPath, "--output", absoluteOutput],
+    cwd2
+  );
+  if (stdout.trim()) console.log(stdout);
+  if (stderr.trim()) console.error(stderr);
+  return exitCode;
+}
+
+// src/commands/init.ts
+import fs3 from "fs";
+import path6 from "path";
+import chalk2 from "chalk";
+var SKILLS_SRC = path6.join(PACKAGE_ROOT, "skills");
+var FRAMEWORK_SKILLS = [
+  "1-module-docs",
+  "2-module-feature-breakdown",
+  "3-module-doc-review",
+  "4-module-tdd-implementation",
+  "5-module-implementation-review",
+  "app-compose-1-requirement-analysis",
+  "app-compose-2-requirements-breakdown",
+  "app-compose-3-doc-review",
+  "app-compose-4-design-mock",
+  "app-compose-5-design-mock-review",
+  "app-compose-6-implementation-spec",
+  "mock-scenario"
+];
+function copyDirectoryRecursive(srcDir, destDir, force) {
+  let copied = 0;
+  let skipped = 0;
+  for (const entry of fs3.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path6.join(srcDir, entry.name);
+    const destPath = path6.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      const sub = copyDirectoryRecursive(srcPath, destPath, force);
+      copied += sub.copied;
+      skipped += sub.skipped;
+    } else {
+      if (!force && fs3.existsSync(destPath)) {
+        skipped++;
+        continue;
+      }
+      fs3.mkdirSync(destDir, { recursive: true });
+      fs3.copyFileSync(srcPath, destPath);
+      copied++;
+    }
+  }
+  return { copied, skipped };
+}
+function runInit(cwd2, force) {
+  console.log(chalk2.bold("erp-kit init\n"));
+  const skillsDest = path6.join(cwd2, ".agents", "skills");
+  let copiedCount = 0;
+  let skippedCount = 0;
+  for (const skill of FRAMEWORK_SKILLS) {
+    const srcSkillDir = path6.join(SKILLS_SRC, skill);
+    if (!fs3.existsSync(srcSkillDir)) continue;
+    const destDir = path6.join(skillsDest, skill);
+    const result = copyDirectoryRecursive(srcSkillDir, destDir, force);
+    copiedCount += result.copied;
+    if (result.skipped > 0) {
+      console.log(chalk2.yellow(`  Skipped ${skill}/ (${result.skipped} existing files)`));
+      skippedCount += result.skipped;
+    }
+  }
+  console.log(chalk2.green(`  Copied ${copiedCount} skill files to .agents/skills/`));
+  if (skippedCount > 0) {
+    console.log(
+      chalk2.yellow(`  Skipped ${skippedCount} existing files (use --force to overwrite)`)
+    );
+  }
+  const claudeSkills = path6.join(cwd2, ".claude", "skills");
+  const relTarget = path6.relative(path6.dirname(claudeSkills), skillsDest);
+  const claudeSkillsExists = (() => {
+    try {
+      fs3.lstatSync(claudeSkills);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  if (claudeSkillsExists) {
+    const stat2 = fs3.lstatSync(claudeSkills);
+    if (stat2.isSymbolicLink()) {
+      const current = fs3.readlinkSync(claudeSkills);
+      if (current === relTarget) {
+        console.log(chalk2.green("  .claude/skills -> .agents/skills/ (already linked)"));
+      } else if (force) {
+        fs3.unlinkSync(claudeSkills);
+        fs3.symlinkSync(relTarget, claudeSkills);
+        console.log(chalk2.green("  .claude/skills -> .agents/skills/ (relinked)"));
+      } else {
+        console.log(
+          chalk2.yellow(`  Skipped .claude/skills (symlink exists -> ${current}, use --force)`)
+        );
+      }
+    } else {
+      console.log(chalk2.yellow("  Skipped .claude/skills (directory exists, not a symlink)"));
+    }
+  } else {
+    fs3.mkdirSync(path6.dirname(claudeSkills), { recursive: true });
+    fs3.symlinkSync(relTarget, claudeSkills);
+    console.log(chalk2.green("  .claude/skills -> .agents/skills/ (linked)"));
+  }
+  console.log(chalk2.bold.green("\nDone! Run `erp-kit check` to validate your docs."));
+  return 0;
+}
+
+// src/commands/mock/index.ts
+import { z } from "zod";
+import { defineCommand, arg } from "politty";
+
+// src/commands/mock/start.ts
+import { createServer, request as httpRequest } from "http";
+import { createServer as createNetServer } from "net";
+import { existsSync, readdirSync } from "fs";
+import { resolve as resolve2, relative, join } from "path";
+
+// src/mockServer.ts
+import { readFileSync } from "fs";
+import { dirname, resolve } from "path";
+async function createMockServer(mockJsonPath, port) {
+  const { MockoonServer, createLoggerInstance, listenServerEvents } = await import("@mockoon/commons-server");
+  const resolvedPath = resolve(mockJsonPath);
+  const environment = JSON.parse(readFileSync(resolvedPath, "utf-8"));
+  if (port !== void 0) {
+    environment.port = port;
+  }
+  const actualPort = environment.port;
+  const logger = createLoggerInstance(null);
+  const server = new MockoonServer(environment, {
+    environmentDirectory: dirname(resolvedPath),
+    enableAdminApi: false,
+    disableTls: true,
+    enableRandomLatency: false,
+    maxTransactionLogs: 100,
+    envVarsPrefix: "MOCKOON_"
+  });
+  listenServerEvents(server, environment, logger, false);
+  await new Promise((resolve4, reject) => {
+    server.on("started", resolve4);
+    server.on("error", (errorCode, originalError) => {
+      reject(originalError ?? new Error(`Mockoon error: ${errorCode}`));
+    });
+    server.start();
+  });
+  return {
+    url: `http://127.0.0.1:${actualPort}`,
+    port: actualPort,
+    stop: () => new Promise((resolve4) => {
+      server.on("stopped", resolve4);
+      server.stop();
+    })
+  };
+}
+
+// src/commands/mock/start.ts
+function readdirSafe(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return [];
+  }
+}
+function discoverMocks(mocksDir, filters) {
+  const mocks = [];
+  for (const provider of readdirSafe(mocksDir)) {
+    const providerDir = join(mocksDir, provider);
+    for (const scenario of readdirSafe(providerDir)) {
+      const mockPath = join(providerDir, scenario, "mock.json");
+      if (!existsSync(mockPath)) continue;
+      mocks.push({ provider, scenario, mockPath });
+    }
+  }
+  if (filters.length === 0) return mocks;
+  return mocks.filter(
+    ({ provider, scenario }) => filters.some((f) => f === provider || f === `${provider}/${scenario}`)
+  );
+}
+function findFreePort() {
+  return new Promise((resolve4, reject) => {
+    const srv = createNetServer();
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      srv.close(() => resolve4(port));
+    });
+    srv.on("error", reject);
+  });
+}
+async function startMock(mock) {
+  const port = await findFreePort();
+  const server = await createMockServer(mock.mockPath, port);
+  const route = `/${mock.provider}/${mock.scenario}`;
+  return { server, route, provider: mock.provider, scenario: mock.scenario };
+}
+function createProxy(routeTable) {
+  return createServer((req, res) => {
+    const match = req.url?.match(/^\/([^/?]+)\/([^/?]+)(\/[^?]*)?(\?.*)?$/);
+    if (!match) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Not found. Use /{provider}/{scenario}/..." }));
+      return;
+    }
+    const [, provider, scenario] = match;
+    const key = `/${provider}/${scenario}`;
+    const target = routeTable.get(key);
+    if (!target) {
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: `Unknown route: ${key}`,
+          available: [...routeTable.keys()]
+        })
+      );
+      return;
+    }
+    const downstream = (req.url ?? "/").slice(key.length) || "/";
+    const proxyReq = httpRequest(
+      {
+        hostname: "127.0.0.1",
+        port: target.server.port,
+        path: downstream,
+        method: req.method,
+        headers: { ...req.headers, host: `127.0.0.1:${target.server.port}` }
+      },
+      (proxyRes) => {
+        res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+        proxyRes.pipe(res);
+      }
+    );
+    proxyReq.on("error", (err) => {
+      if (!res.headersSent) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+      }
+      res.end(JSON.stringify({ error: "Bad gateway", detail: err.message }));
+    });
+    req.pipe(proxyReq);
+  });
+}
+async function runMockStart(mocksRoot, filters, port) {
+  const mocksDir = resolve2(mocksRoot);
+  const mocks = discoverMocks(mocksDir, filters);
+  if (mocks.length === 0) {
+    console.error("No matching mocks found.");
+    if (filters.length > 0) {
+      console.error(`Filters: ${filters.join(", ")}`);
+      console.error(`Available mocks are under: ${relative(process.cwd(), mocksDir)}/`);
+    }
+    return 1;
+  }
+  console.log(`Starting ${mocks.length} mock(s)...
+`);
+  const running = [];
+  for (const mock of mocks) {
+    const info = await startMock(mock);
+    running.push(info);
+  }
+  const routeTable = /* @__PURE__ */ new Map();
+  for (const r of running) {
+    routeTable.set(r.route, r);
+  }
+  console.log("Route table:");
+  console.log("\u2500".repeat(50));
+  for (const [route, { server }] of routeTable) {
+    console.log(`  ${route}  \u2192  127.0.0.1:${server.port}`);
+  }
+  console.log("\u2500".repeat(50));
+  const proxy = createProxy(routeTable);
+  proxy.listen(port, () => {
+    console.log(`
+Reverse proxy listening on http://localhost:${port}`);
+    console.log("Press Ctrl+C to stop all mocks.\n");
+  });
+  function shutdown() {
+    console.log("\nShutting down...");
+    proxy.close();
+    for (const { server } of running) {
+      void server.stop();
+    }
+    process.exit(0);
+  }
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  return new Promise(() => void 0);
+}
+
+// src/commands/mock/validate.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { join as join2, resolve as resolve3, relative as relative2, dirname as dirname2, basename } from "path";
+import chalk3 from "chalk";
+function pass(msg) {
+  console.log(chalk3.green(`\u2713 ${msg}`));
+}
+function fail(ctx, msg) {
+  console.log(chalk3.red(`\u2717 ${msg}`));
+  ctx.failures++;
+}
+async function subdirs(dir) {
+  const entries = await readdir(dir);
+  const dirs = [];
+  for (const entry of entries) {
+    const full = join2(dir, entry);
+    const s = await stat(full);
+    if (s.isDirectory()) dirs.push(entry);
+  }
+  return dirs.sort();
+}
+function checkStructure(ctx, entries, label) {
+  if (entries.includes("README.md")) {
+    pass(`${label}: has README.md`);
+  } else {
+    fail(ctx, `${label}: missing README.md`);
+  }
+  if (entries.includes("mock.json")) {
+    pass(`${label}: has mock.json`);
+    return true;
+  }
+  fail(ctx, `${label}: missing mock.json`);
+  return false;
+}
+async function checkSchema(ctx, data, label) {
+  const commons = await import("@mockoon/commons");
+  const schema = commons.EnvironmentSchemaNoFix;
+  const result = schema.validate(data, { abortEarly: false });
+  if (!result.error) {
+    pass(`${label}: valid Mockoon schema`);
+  } else {
+    for (const detail of result.error.details) {
+      fail(ctx, `${label}: schema \u2014 ${detail.message}`);
+    }
+  }
+}
+function checkResponseQuality(ctx, data, label) {
+  const routes = data.routes ?? [];
+  for (const route of routes) {
+    for (const resp of route.responses ?? []) {
+      const respLabel = `${label} \u2192 ${route.uuid}/${resp.uuid}`;
+      const headers = resp.headers ?? [];
+      const hasContentType = headers.some((h) => h.key.toLowerCase() === "content-type");
+      if (hasContentType) {
+        pass(`${respLabel}: has Content-Type`);
+      } else {
+        fail(ctx, `${respLabel}: missing Content-Type header`);
+      }
+      if (resp.label && resp.label.trim().length > 0) {
+        pass(`${respLabel}: has label "${resp.label}"`);
+      } else {
+        fail(ctx, `${respLabel}: missing or empty label`);
+      }
+    }
+  }
+}
+function checkDatabucketRefs(ctx, data, label) {
+  const bucketIds = new Set((data.data ?? []).map((d) => d.id));
+  for (const route of data.routes ?? []) {
+    for (const resp of route.responses ?? []) {
+      if (resp.bodyType === "DATABUCKET") {
+        const respLabel = `${label} \u2192 ${route.uuid}/${resp.uuid}`;
+        if (resp.databucketID && bucketIds.has(resp.databucketID)) {
+          pass(`${respLabel}: databucket "${resp.databucketID}" exists`);
+        } else {
+          fail(ctx, `${respLabel}: databucketID "${resp.databucketID}" not found in data array`);
+        }
+      }
+    }
+  }
+}
+async function discoverAllScenarios(mocksDir) {
+  const scenarios = [];
+  const providers = await subdirs(mocksDir);
+  for (const provider of providers) {
+    const providerDir = join2(mocksDir, provider);
+    for (const scenario of await subdirs(providerDir)) {
+      scenarios.push(`${provider}/${scenario}`);
+    }
+  }
+  return scenarios;
+}
+function resolveScenarioDir(arg3) {
+  const abs = resolve3(arg3);
+  if (basename(abs) === "mock.json") return dirname2(abs);
+  return abs;
+}
+async function validateScenario(ctx, scenarioDir, mocksDir) {
+  const label = relative2(mocksDir, scenarioDir);
+  console.log(chalk3.bold(`
+\u2500\u2500 ${label} \u2500\u2500`));
+  let entries;
+  try {
+    entries = await readdir(scenarioDir);
+  } catch {
+    fail(ctx, `${label}: directory not found`);
+    return;
+  }
+  const hasMock = checkStructure(ctx, entries, label);
+  if (!hasMock) return;
+  const mockPath = join2(scenarioDir, "mock.json");
+  let data;
+  try {
+    data = JSON.parse(await readFile(mockPath, "utf-8"));
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    fail(ctx, `${label}: invalid JSON \u2014 ${errMsg}`);
+    return;
+  }
+  await checkSchema(ctx, data, label);
+  checkResponseQuality(ctx, data, label);
+  checkDatabucketRefs(ctx, data, label);
+}
+async function runMockValidate(mocksRoot, paths) {
+  const ctx = { failures: 0 };
+  const mocksDir = resolve3(mocksRoot);
+  const targets = paths.length > 0 ? paths.map(resolveScenarioDir) : (await discoverAllScenarios(mocksDir)).map((s) => join2(mocksDir, s));
+  if (targets.length === 0) {
+    fail(ctx, "No scenarios found under mocks/");
+    return 1;
+  }
+  console.log(chalk3.bold("\nValidating mock configs...\n"));
+  for (const target of targets) {
+    await validateScenario(ctx, target, mocksDir);
+  }
+  console.log(chalk3.bold("\n\u2500\u2500 summary \u2500\u2500"));
+  if (ctx.failures === 0) {
+    console.log(chalk3.green("\u2713 All checks passed"));
+  } else {
+    console.log(chalk3.red(`\u2717 ${ctx.failures} check(s) failed`));
+  }
+  return ctx.failures === 0 ? 0 : 1;
+}
+
+// src/commands/mock/index.ts
+var startCommand = defineCommand({
+  name: "start",
+  description: "Start mock API servers with reverse proxy",
+  args: z.object({
+    mocksRoot: arg(z.string().default("./mocks"), {
+      description: "Path to mocks directory"
+    }),
+    port: arg(z.coerce.number().default(3e3), {
+      alias: "p",
+      description: "Reverse proxy port"
+    }),
+    filter: arg(z.array(z.string()).default([]), {
+      positional: true,
+      description: "Filter by provider or provider/scenario"
+    })
+  }),
+  run: async (args) => {
+    const exitCode = await runMockStart(args.mocksRoot, args.filter, args.port);
+    process.exit(exitCode);
+  }
+});
+var validateCommand = defineCommand({
+  name: "validate",
+  description: "Validate mock scenario configs",
+  args: z.object({
+    mocksRoot: arg(z.string().default("./mocks"), {
+      description: "Path to mocks directory"
+    }),
+    paths: arg(z.array(z.string()).default([]), {
+      positional: true,
+      description: "Specific scenario paths to validate"
+    })
+  }),
+  run: async (args) => {
+    const exitCode = await runMockValidate(args.mocksRoot, args.paths);
+    process.exit(exitCode);
+  }
+});
+var mockCommand = defineCommand({
+  name: "mock",
+  description: "Mock API server management",
+  subCommands: {
+    start: startCommand,
+    validate: validateCommand
+  }
+});
+
+// src/cli.ts
+var cwd = process.cwd();
+var rootArgs = z2.object({
+  modulesRoot: arg2(z2.string().optional(), {
+    alias: "m",
+    description: "Path to modules directory"
+  }),
+  appRoot: arg2(z2.string().optional(), {
+    alias: "a",
+    description: "Path to app-compose directory (apps/ or examples/)"
+  })
+});
+function requireRoot(args) {
+  const paths = { modulesRoot: args.modulesRoot, appRoot: args.appRoot };
+  if (!paths.modulesRoot && !paths.appRoot) {
+    console.error("At least one of --modules-root or --app-root is required.");
+    process.exit(2);
+  }
+  return paths;
+}
+var checkCommand = defineCommand2({
+  name: "check",
+  description: "Validate docs against schemas",
+  args: rootArgs,
+  run: async (args) => {
+    const paths = requireRoot(args);
+    const exitCode = await runCheck(paths, cwd);
+    process.exit(exitCode);
+  }
+});
+var syncCheckCommand = defineCommand2({
+  name: "sync-check",
+  description: "Validate source <-> doc correspondence",
+  args: rootArgs,
+  run: async (args) => {
+    const paths = requireRoot(args);
+    const result = await runSyncCheck(paths, cwd);
+    console.log(formatSyncCheckReport(result));
+    process.exit(result.exitCode);
+  }
+});
+var scaffoldCommand = defineCommand2({
+  name: "scaffold",
+  description: "Generate doc file from schema template",
+  args: rootArgs.extend({
+    type: arg2(z2.enum(ALL_TYPES), {
+      positional: true,
+      description: `Scaffold type (${ALL_TYPES.join(", ")})`
+    }),
+    parent: arg2(z2.string(), {
+      positional: true,
+      description: "Parent name (module or app name)"
+    }),
+    name: arg2(z2.string().optional(), {
+      positional: true,
+      description: "Item name (required for most types)"
+    })
+  }),
+  run: async (args) => {
+    const paths = requireRoot(args);
+    const root = isModuleType(args.type) ? paths.modulesRoot : paths.appRoot;
+    if (!root) {
+      console.error(
+        `--${isModuleType(args.type) ? "modules-root" : "app-root"} is required for scaffold type "${args.type}".`
+      );
+      process.exit(2);
+    }
+    const exitCode = await runScaffold(
+      args.type,
+      args.parent,
+      args.name,
+      root,
+      cwd
+    );
+    process.exit(exitCode);
+  }
+});
+var initCommand = defineCommand2({
+  name: "init",
+  description: "Set up consumer repo with framework skills",
+  args: z2.object({
+    force: arg2(z2.boolean().default(false), {
+      alias: "f",
+      description: "Overwrite existing skills"
+    })
+  }),
+  run: (args) => {
+    const exitCode = runInit(cwd, args.force);
+    process.exit(exitCode);
+  }
+});
+var main = defineCommand2({
+  name: "erp-kit",
+  description: "Documentation validation and scaffolding tool",
+  subCommands: {
+    check: checkCommand,
+    "sync-check": syncCheckCommand,
+    scaffold: scaffoldCommand,
+    init: initCommand,
+    mock: mockCommand
+  }
+});
+void runMain(main);