@tailor-platform/erp-kit 0.2.0 → 0.2.2

package/dist/cli.js

@@ -1,1654 +0,0 @@
-#!/usr/bin/env node
-
-// src/cli.ts
-import { runMain } from "politty";
-
-// src/commands/index.ts
-import { z as z5 } from "zod";
-import { defineCommand as defineCommand5, arg as arg5 } from "politty";
-
-// src/commands/init.ts
-import fs from "fs";
-import path2 from "path";
-import chalk from "chalk";
-
-// src/util.ts
-import path from "path";
-var PACKAGE_ROOT = path.resolve(import.meta.dirname, "..");
-
-// src/commands/init.ts
-var SKILLS_SRC = path2.join(PACKAGE_ROOT, "skills");
-function discoverFrameworkSkills() {
-  if (!fs.existsSync(SKILLS_SRC)) return [];
-  return fs.readdirSync(SKILLS_SRC, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("erp-kit-")).map((entry) => entry.name);
-}
-function copyDirectoryRecursive(srcDir, destDir, force) {
-  let copied = 0;
-  let skipped = 0;
-  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
-    const srcPath = path2.join(srcDir, entry.name);
-    const destPath = path2.join(destDir, entry.name);
-    if (entry.isDirectory()) {
-      const sub = copyDirectoryRecursive(srcPath, destPath, force);
-      copied += sub.copied;
-      skipped += sub.skipped;
-    } else {
-      if (!force && fs.existsSync(destPath)) {
-        skipped++;
-        continue;
-      }
-      fs.mkdirSync(destDir, { recursive: true });
-      fs.copyFileSync(srcPath, destPath);
-      copied++;
-    }
-  }
-  return { copied, skipped };
-}
-function runInit(cwd5, force) {
-  console.log(chalk.bold("erp-kit init\n"));
-  const skillsDest = path2.join(cwd5, ".agents", "skills");
-  if (force && fs.existsSync(skillsDest)) {
-    let removedCount = 0;
-    for (const entry of fs.readdirSync(skillsDest)) {
-      if (entry.startsWith("erp-kit-")) {
-        fs.rmSync(path2.join(skillsDest, entry), { recursive: true, force: true });
-        removedCount++;
-      }
-    }
-    if (removedCount > 0) {
-      console.log(chalk.green(`  Removed ${removedCount} existing erp-kit-* skills`));
-    }
-  }
-  let copiedCount = 0;
-  let skippedCount = 0;
-  const frameworkSkills = discoverFrameworkSkills();
-  for (const skill of frameworkSkills) {
-    const srcSkillDir = path2.join(SKILLS_SRC, skill);
-    if (!fs.existsSync(srcSkillDir)) continue;
-    const destDir = path2.join(skillsDest, skill);
-    const result = copyDirectoryRecursive(srcSkillDir, destDir, force);
-    copiedCount += result.copied;
-    if (result.skipped > 0) {
-      console.log(chalk.yellow(`  Skipped ${skill}/ (${result.skipped} existing files)`));
-      skippedCount += result.skipped;
-    }
-  }
-  console.log(chalk.green(`  Copied ${copiedCount} skill files to .agents/skills/`));
-  if (skippedCount > 0) {
-    console.log(
-      chalk.yellow(`  Skipped ${skippedCount} existing files (use --force to overwrite)`)
-    );
-  }
-  const claudeSkills = path2.join(cwd5, ".claude", "skills");
-  const relTarget = path2.relative(path2.dirname(claudeSkills), skillsDest);
-  const claudeSkillsExists = (() => {
-    try {
-      fs.lstatSync(claudeSkills);
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-  if (claudeSkillsExists) {
-    const stat2 = fs.lstatSync(claudeSkills);
-    if (stat2.isSymbolicLink()) {
-      const current = fs.readlinkSync(claudeSkills);
-      if (current === relTarget) {
-        console.log(chalk.green("  .claude/skills -> .agents/skills/ (already linked)"));
-      } else if (force) {
-        fs.unlinkSync(claudeSkills);
-        fs.symlinkSync(relTarget, claudeSkills);
-        console.log(chalk.green("  .claude/skills -> .agents/skills/ (relinked)"));
-      } else {
-        console.log(
-          chalk.yellow(`  Skipped .claude/skills (symlink exists -> ${current}, use --force)`)
-        );
-      }
-    } else {
-      console.log(chalk.yellow("  Skipped .claude/skills (directory exists, not a symlink)"));
-    }
-  } else {
-    fs.mkdirSync(path2.dirname(claudeSkills), { recursive: true });
-    fs.symlinkSync(relTarget, claudeSkills);
-    console.log(chalk.green("  .claude/skills -> .agents/skills/ (linked)"));
-  }
-  console.log(chalk.bold.green("\nDone! Run `erp-kit check` to validate your docs."));
-  return 0;
-}
-
-// src/commands/license.ts
-import fs2 from "fs";
-import { execSync } from "child_process";
-var licenseGroups = {
-  // https://github.com/google/licenseclassifier/blob/e6a9bb99b5a6f71d5a34336b8245e305f5430f99/license_type.go#L225
-  reciprocal: [
-    "APSL-1.0",
-    "APSL-1.1",
-    "APSL-1.2",
-    "APSL-2.0",
-    "CDDL-1.0",
-    "CDDL-1.1",
-    "CPL-1.0",
-    "EPL-1.0",
-    "EPL-2.0",
-    "FreeImage",
-    "IPL-1.0",
-    "MPL-1.0",
-    "MPL-1.1",
-    "MPL-2.0",
-    "Ruby"
-  ],
-  // https://github.com/google/licenseclassifier/blob/e6a9bb99b5a6f71d5a34336b8245e305f5430f99/license_type.go#L249
-  notice: [
-    "AFL-1.1",
-    "AFL-1.2",
-    "AFL-2.0",
-    "AFL-2.1",
-    "AFL-3.0",
-    "Apache-1.0",
-    "Apache-1.1",
-    "Apache-2.0",
-    "Artistic-1.0-cl8",
-    "Artistic-1.0-Perl",
-    "Artistic-1.0",
-    "Artistic-2.0",
-    "BSL-1.0",
-    "BSD-2-Clause-FreeBSD",
-    "BSD-2-Clause-NetBSD",
-    "BSD-2-Clause",
-    "BSD-3-Clause-Attribution",
-    "BSD-3-Clause-Clear",
-    "BSD-3-Clause-LBNL",
-    "BSD-3-Clause",
-    "BSD-4-Clause",
-    "BSD-4-Clause-UC",
-    "BSD-Protection",
-    "CC-BY-1.0",
-    "CC-BY-2.0",
-    "CC-BY-2.5",
-    "CC-BY-3.0",
-    "CC-BY-4.0",
-    "FTL",
-    "ISC",
-    "ImageMagick",
-    "Libpng",
-    "Lil-1.0",
-    "Linux-OpenIB",
-    "LPL-1.02",
-    "LPL-1.0",
-    "MS-PL",
-    "MIT",
-    "NCSA",
-    "OpenSSL",
-    "PHP-3.01",
-    "PHP-3.0",
-    "PIL",
-    "Python-2.0",
-    "Python-2.0-complete",
-    "PostgreSQL",
-    "SGI-B-1.0",
-    "SGI-B-1.1",
-    "SGI-B-2.0",
-    "Unicode-DFS-2015",
-    "Unicode-DFS-2016",
-    "Unicode-TOU",
-    "UPL-1.0",
-    "W3C-19980720",
-    "W3C-20150513",
-    "W3C",
-    "X11",
-    "Xnet",
-    "Zend-2.0",
-    "zlib-acknowledgement",
-    "Zlib",
-    "ZPL-1.1",
-    "ZPL-2.0",
-    "ZPL-2.1"
-  ],
-  // https://github.com/google/licenseclassifier/blob/e6a9bb99b5a6f71d5a34336b8245e305f5430f99/license_type.go#L324
-  unencumbered: ["CC0-1.0", "Unlicense", "0BSD"]
-};
-function buildAllowSet(config) {
-  const set = /* @__PURE__ */ new Set();
-  for (const group of config.groups) {
-    for (const license of licenseGroups[group]) {
-      set.add(license);
-    }
-  }
-  if (config.allow) {
-    for (const license of config.allow) {
-      set.add(license);
-    }
-  }
-  if (config.deny) {
-    for (const license of config.deny) {
-      set.delete(license);
-    }
-  }
-  return set;
-}
-function isLicenseAllowed(licenseString, allowSet) {
-  if (/\s+(?:OR|AND)\s+/i.test(licenseString)) {
-    const licenses = licenseString.replace(/[()]/g, "").trim().split(/\s+(?:OR|AND)\s+/i).map((l) => l.trim()).filter((l) => l.length > 0);
-    return licenses.every((l) => allowSet.has(l));
-  }
-  return allowSet.has(licenseString);
-}
-function runLicenseList() {
-  for (const [group, licenses] of Object.entries(licenseGroups)) {
-    console.log(`${group} (${licenses.length} licenses):`);
-    for (const license of licenses) {
-      console.log(`  ${license}`);
-    }
-    console.log();
-  }
-  return 0;
-}
-function runLicenseCheck(configPath) {
-  const raw = fs2.readFileSync(configPath, "utf-8");
-  const config = JSON.parse(raw);
-  const validGroups = Object.keys(licenseGroups);
-  for (const group of config.groups) {
-    if (!validGroups.includes(group)) {
-      console.error(`Unknown license group: "${group}". Valid groups: ${validGroups.join(", ")}`);
-      return 2;
-    }
-  }
-  const allowSet = buildAllowSet(config);
-  console.log("Checking licenses...\n");
-  execSync("pnpm licenses list", { stdio: "inherit" });
-  const output = execSync("pnpm licenses list --json");
-  const licensesJson = JSON.parse(output.toString());
-  const violations = [];
-  for (const [license, packages] of Object.entries(licensesJson)) {
-    if (!isLicenseAllowed(license, allowSet)) {
-      for (const pkg of packages) {
-        violations.push({ package: pkg.name, license });
-      }
-    }
-  }
-  if (violations.length === 0) {
-    console.log("All licenses are allowed.");
-    return 0;
-  }
-  console.error("Found dependencies with disallowed licenses:\n");
-  for (const violation of violations) {
-    console.error(`  - ${violation.package}`);
-    console.error(`    License: ${violation.license}
-`);
-  }
-  return 1;
-}
-
-// src/commands/module/index.ts
-import { z as z2 } from "zod";
-import { defineCommand as defineCommand2, arg as arg2 } from "politty";
-
-// src/mdschema.ts
-import path3 from "path";
-import fs3 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(fs3.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 path3.join(path3.dirname(pkgPath), bin);
-}
-function runMdschema(args, cwd5) {
-  return new Promise((resolve4) => {
-    execFile(
-      getMdschemaBin(),
-      args,
-      { encoding: "utf-8", cwd: cwd5, 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 path4 from "path";
-var SCHEMAS_ROOT = path4.join(PACKAGE_ROOT, "schemas");
-var MODULE_SCHEMAS = {
-  module: path4.join(SCHEMAS_ROOT, "module", "module.yml"),
-  command: path4.join(SCHEMAS_ROOT, "module", "command.yml"),
-  model: path4.join(SCHEMAS_ROOT, "module", "model.yml"),
-  feature: path4.join(SCHEMAS_ROOT, "module", "feature.yml"),
-  query: path4.join(SCHEMAS_ROOT, "module", "query.yml")
-};
-var APP_COMPOSE_SCHEMAS = {
-  requirements: path4.join(SCHEMAS_ROOT, "app-compose", "requirements.yml"),
-  actors: path4.join(SCHEMAS_ROOT, "app-compose", "actors.yml"),
-  "business-flow": path4.join(SCHEMAS_ROOT, "app-compose", "business-flow.yml"),
-  story: path4.join(SCHEMAS_ROOT, "app-compose", "story.yml"),
-  screen: path4.join(SCHEMAS_ROOT, "app-compose", "screen.yml"),
-  resolver: path4.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]*/docs/queries/*.md`, schemaKey: "query" },
-      { 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, cwd5) {
-  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],
-        cwd5
-      );
-      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 path5 from "path";
-import fg from "fast-glob";
-import chalk2 from "chalk";
-function moduleCategories(root) {
-  return [
-    {
-      name: "command",
-      sourcePattern: `${root}/*/command/*.ts`,
-      docPattern: `${root}/*/docs/commands/*.md`,
-      exclusions: [/\.test\.ts$/, /\.generated\.ts$/]
-    },
-    {
-      name: "model",
-      sourcePattern: `${root}/*/db/*.ts`,
-      docPattern: `${root}/*/docs/models/*.md`,
-      exclusions: [/\.test\.ts$/, /^index\.ts$/]
-    },
-    {
-      name: "query",
-      sourcePattern: `${root}/*/query/*.ts`,
-      docPattern: `${root}/*/docs/queries/*.md`,
-      exclusions: [/\.test\.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, cwd5) {
-  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: cwd5 });
-    const docs = await fg(category.docPattern, { cwd: cwd5 });
-    const sourceBasenames = /* @__PURE__ */ new Map();
-    const docBasenames = /* @__PURE__ */ new Map();
-    for (const sourcePath of sources) {
-      const fileName = path5.basename(sourcePath);
-      if (shouldExclude(fileName, category.exclusions)) continue;
-      let basename2 = path5.basename(sourcePath, path5.extname(sourcePath));
-      if (basename2.endsWith(".generated")) {
-        basename2 = basename2.slice(0, -".generated".length);
-      }
-      sourceBasenames.set(basename2.toLowerCase(), sourcePath);
-    }
-    for (const docPath of docs) {
-      const basename2 = path5.basename(docPath, path5.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(chalk2.bold("docs-sync-check: Checking source-documentation correspondence...\n"));
-  if (result.errors.length > 0) {
-    lines.push(chalk2.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(chalk2.cyan(`  Category: ${category}
-`));
-      for (const error of categoryErrors) {
-        if (error.type === "missing-doc") {
-          lines.push(`  ${chalk2.red(error.sourcePath)}`);
-          lines.push(`    ${chalk2.yellow("Missing documentation for:")} ${error.expectedBasename}`);
-        } else {
-          lines.push(`  ${chalk2.red(error.docPath)}`);
-          lines.push(
-            `    ${chalk2.yellow("Orphaned documentation:")} no source file for ${error.expectedBasename}`
-          );
-        }
-        lines.push("");
-      }
-    }
-  } else {
-    lines.push(chalk2.green("All source files have corresponding documentation.\n"));
-  }
-  lines.push(chalk2.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(chalk2.red(`  Errors: ${result.errors.length}`));
-    lines.push("");
-    lines.push(chalk2.red.bold(`docs-sync-check failed with ${result.errors.length} error(s).`));
-  } else {
-    lines.push(chalk2.green("  Errors: 0"));
-    lines.push("");
-    lines.push(chalk2.green.bold("docs-sync-check passed."));
-  }
-  return lines.join("\n");
-}
-
-// src/commands/scaffold.ts
-import path6 from "path";
-import fs4 from "fs";
-
-// src/commands/scaffold-templates.ts
-function getModuleSrcTemplates() {
-  return [
-    { type: "dir", path: "db" },
-    { type: "dir", path: "command" },
-    { type: "dir", path: "executor" },
-    { type: "dir", path: "generated" },
-    { type: "dir", path: "query" },
-    { type: "file", path: "module.ts", content: () => MODULE_TEMPLATE },
-    { type: "file", path: "index.ts", content: () => INDEX_TEMPLATE },
-    { type: "file", path: "permissions.ts", content: (n) => permissionsTemplate(n) },
-    { type: "file", path: "tailor.config.ts", content: (n) => tailorConfigTemplate(n) },
-    { type: "file", path: "lib/errors.ts", content: () => ERRORS_TEMPLATE },
-    { type: "file", path: "lib/types.ts", content: () => TYPES_TEMPLATE },
-    { type: "file", path: "testing/fixtures.ts", content: () => FIXTURES_TEMPLATE }
-  ];
-}
-var MODULE_TEMPLATE = `export const defineModule = () => {
-  return {
-    db: {},
-    commands: {},
-    queries: {},
-  };
-};
-`;
-var INDEX_TEMPLATE = `export { defineModule } from "./module";
-export { permissions, own, all } from "./permissions";
-`;
-var ERRORS_TEMPLATE = `import { createDomainError } from "../../shared/internal";
-`;
-var TYPES_TEMPLATE = `import type { InferSchema, Selectable, Insertable, Updateable } from "../../shared/internal";
-import type { DB } from "../generated/kysely-tailordb";
-
-export type Schema = InferSchema<DB>;
-`;
-var FIXTURES_TEMPLATE = `// Add test fixtures here
-`;
-function permissionsTemplate(moduleName) {
-  return `import { definePermissions } from "../shared/internal";
-
-export const { permissions, own, all } = definePermissions("${moduleName}", [] as const);
-`;
-}
-function tailorConfigTemplate(moduleName) {
-  return `import { defineConfig, defineGenerators } from "@tailor-platform/sdk";
-
-export default defineConfig({
-  name: "${moduleName}",
-  db: { "main-db": { files: [\`./db/*.ts\`] } },
-});
-
-export const generators = defineGenerators(
-  ["@tailor-platform/kysely-type", { distPath: \`./generated/kysely-tailordb.ts\` }],
-  ["@tailor-platform/enum-constants", { distPath: "./generated/enums.ts" }],
-);
-`;
-}
-
-// src/commands/scaffold.ts
-var MODULE_TYPES = ["module", "feature", "command", "model", "query"];
-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",
-  query: "docs/queries"
-};
-var APP_DIR_MAP = {
-  actors: "docs/actors",
-  "business-flow": "docs/business-flow",
-  screen: "docs/screen",
-  resolver: "docs/resolver"
-};
-function resolveScaffoldPath(type, parentName, name, root) {
-  if (type === "module" || type === "requirements") {
-    return path6.join(root, parentName, "README.md");
-  }
-  if (!name) {
-    throw new Error(`Name is required for scaffold type "${type}"`);
-  }
-  if (type === "business-flow") {
-    return path6.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 path6.join(root, parentName, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
-  }
-  if (MODULE_DIR_MAP[type]) {
-    return path6.join(root, parentName, MODULE_DIR_MAP[type], `${name}.md`);
-  }
-  if (APP_DIR_MAP[type]) {
-    return path6.join(root, parentName, APP_DIR_MAP[type], `${name}.md`);
-  }
-  throw new Error(`Unknown scaffold type: ${type}`);
-}
-async function runScaffold(type, parentName, name, root, cwd5) {
-  const outputPath = resolveScaffoldPath(type, parentName, name, root);
-  const absoluteOutput = path6.resolve(cwd5, outputPath);
-  if (fs4.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 {
-    fs4.mkdirSync(path6.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],
-    cwd5
-  );
-  if (stdout.trim()) console.log(stdout);
-  if (stderr.trim()) console.error(stderr);
-  if (exitCode !== 0) return exitCode;
-  if (type === "module") {
-    scaffoldModuleSrc(path6.dirname(absoluteOutput), parentName);
-  }
-  return exitCode;
-}
-function scaffoldModuleSrc(moduleDir, moduleName) {
-  for (const entry of getModuleSrcTemplates()) {
-    const fullPath = path6.join(moduleDir, entry.path);
-    if (entry.type === "dir") {
-      fs4.mkdirSync(fullPath, { recursive: true });
-      fs4.writeFileSync(path6.join(fullPath, ".gitkeep"), "");
-    } else {
-      fs4.mkdirSync(path6.dirname(fullPath), { recursive: true });
-      fs4.writeFileSync(fullPath, entry.content(moduleName));
-    }
-  }
-}
-
-// src/commands/module/list.ts
-import { readdirSync, existsSync } from "fs";
-import { join } from "path";
-import chalk3 from "chalk";
-var MODULES_DIR = join(PACKAGE_ROOT, "src", "modules");
-var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["shared", "testing"]);
-function countFiles(dir, pattern, exclusions) {
-  if (!existsSync(dir)) return 0;
-  return readdirSync(dir).filter((f) => pattern.test(f) && !exclusions.some((p) => p.test(f))).length;
-}
-function listModules() {
-  if (!existsSync(MODULES_DIR)) return [];
-  return readdirSync(MODULES_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DIRS.has(d.name)).map((d) => {
-    const modDir = join(MODULES_DIR, d.name);
-    return {
-      name: d.name,
-      commands: countFiles(join(modDir, "command"), /\.ts$/, [/\.test\.ts$/]),
-      models: countFiles(join(modDir, "db"), /\.ts$/, [/\.test\.ts$/, /^index\.ts$/]),
-      features: countFiles(join(modDir, "docs", "features"), /\.md$/, [])
-    };
-  }).sort((a, b) => a.name.localeCompare(b.name));
-}
-function formatModuleList(modules) {
-  if (modules.length === 0) return "No modules found.";
-  const lines = [];
-  lines.push(chalk3.bold("Modules:\n"));
-  const nameWidth = Math.max(...modules.map((m) => m.name.length), 4);
-  for (const mod of modules) {
-    const counts = [
-      `${mod.commands} commands`,
-      `${mod.models} models`,
-      `${mod.features} features`
-    ].join(", ");
-    lines.push(`  ${mod.name.padEnd(nameWidth)}  ${counts}`);
-  }
-  lines.push("");
-  lines.push(`${modules.length} modules`);
-  return lines.join("\n");
-}
-function runModuleList() {
-  const modules = listModules();
-  console.log(formatModuleList(modules));
-  return 0;
-}
-
-// src/commands/module/generate.ts
-import path8 from "path";
-import { defineCommand, arg } from "politty";
-import { z } from "zod";
-
-// src/generator/generate-code.ts
-import fs5 from "fs";
-import path7 from "path";
-
-// src/generator/parse-command-doc.ts
-import { fromMarkdown } from "mdast-util-from-markdown";
-import { toString } from "mdast-util-to-string";
-function parseCommandDoc(fileName, markdown) {
-  const commandName = fileName.charAt(0).toLowerCase() + fileName.slice(1);
-  const tree = fromMarkdown(markdown);
-  return {
-    commandName,
-    errors: parseErrorScenarios(tree),
-    externalDependencies: parseExternalDependencies(tree)
-  };
-}
-function errorCodeToClassName(code) {
-  const pascal = code.toLowerCase().split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-  return pascal + "Error";
-}
-function isHeading(node) {
-  return node.type === "heading";
-}
-function isList(node) {
-  return node.type === "list";
-}
-function getNodesUnderHeading(tree, headingText) {
-  const nodes = [];
-  let collecting = false;
-  for (const node of tree.children) {
-    if (isHeading(node)) {
-      if (collecting) break;
-      if (node.depth === 2 && toString(node) === headingText) {
-        collecting = true;
-        continue;
-      }
-    }
-    if (collecting) {
-      nodes.push(node);
-    }
-  }
-  return nodes;
-}
-var ERROR_PATTERN = /^([A-Z_]+):\s*(.+)$/;
-function parseErrorScenarios(tree) {
-  const nodes = getNodesUnderHeading(tree, "Error Scenarios");
-  const errors = [];
-  for (const node of nodes) {
-    if (!isList(node)) continue;
-    for (const item of node.children) {
-      const text = toString(item);
-      const match = ERROR_PATTERN.exec(text);
-      if (match) {
-        errors.push({ code: match[1], description: match[2].trim() });
-      }
-    }
-  }
-  return errors;
-}
-var DEPENDENCY_PATTERN = /^([^:]+)::(.+)$/;
-function parseExternalDependencies(tree) {
-  const nodes = getNodesUnderHeading(tree, "External Dependencies");
-  const deps = [];
-  for (const node of nodes) {
-    if (!isList(node)) continue;
-    for (const item of node.children) {
-      const firstChild = item.children[0];
-      if (firstChild?.type !== "paragraph") continue;
-      for (const inline of firstChild.children) {
-        if (inline.type === "link" || inline.type === "linkReference") {
-          const linkText = toString(inline);
-          const match = DEPENDENCY_PATTERN.exec(linkText);
-          if (match) {
-            deps.push({ module: match[1], entity: match[2] });
-          }
-        }
-      }
-    }
-  }
-  return deps;
-}
-
-// src/generator/generate-code.ts
-function generateErrors(docs) {
-  const seen = /* @__PURE__ */ new Set();
-  const lines = [];
-  for (const doc of docs) {
-    for (const error of doc.errors) {
-      if (seen.has(error.code)) continue;
-      seen.add(error.code);
-      const className = errorCodeToClassName(error.code);
-      lines.push(`export const ${className} = createDomainError(`);
-      lines.push(`  "${className}", "${error.code}",`);
-      const escapedDesc = error.description.replace(/`/g, "'");
-      lines.push(`  (identifier: string) => \`${escapedDesc}: \${identifier}\`,`);
-      lines.push(`);`);
-      lines.push(``);
-    }
-  }
-  if (lines.length === 0) return "";
-  return `// @generated \u2014 do not edit
-import { createDomainError } from "../../shared/internal";
-
-${lines.join("\n")}`;
-}
-function generateCommandStub(doc) {
-  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
-  const inputType = `${pascal}Input`;
-  return `import { ok, type CommandContext } from "../../shared/internal";
-import type { DB } from "../generated/kysely-tailordb";
-
-export interface ${inputType} {
-  // TODO: define input fields
-}
-
-export async function run(db: DB, input: ${inputType}, ctx: CommandContext) {
-  // TODO: implement
-  return ok({});
-}
-`;
-}
-function generateTestStub(doc) {
-  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
-  return `import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
-import type { CommandContext } from "../../shared/internal";
-import type { DB } from "../generated/kysely-tailordb";
-import { run, ${pascal}Input } from "./${doc.commandName}";
-
-describe("${doc.commandName} - test scenario", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["TODO:${doc.commandName}"],
-  };
-
-  it("should be implemented", async () => {
-    const { db } = createMockDb<DB>();
-    const result = await run(db, {} as ${pascal}Input, ctx);
-    expect(result.ok).toBe(true);
-  });
-});
-`;
-}
-function generateCommandShell(doc) {
-  const lines = [
-    `// @generated \u2014 do not edit`,
-    `import { defineCommand } from "../../shared/internal";`,
-    `import { permissions } from "../lib/permissions.generated";`,
-    `import { run } from "./${doc.commandName}";`,
-    ``,
-    `export const ${doc.commandName} = defineCommand(permissions.${doc.commandName}, run);`,
-    ``
-  ];
-  return lines.join("\n");
-}
-function generateQueryShell(doc) {
-  const lines = [
-    `// @generated \u2014 do not edit`,
-    `import { defineQuery } from "../../shared/internal";`,
-    `import { run } from "./${doc.commandName}";`,
-    ``,
-    `export const ${doc.commandName} = defineQuery(run);`,
-    ``
-  ];
-  return lines.join("\n");
-}
-function generateQueryStub(doc) {
-  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
-  const inputType = `${pascal}Input`;
-  return `import type { ReadonlyDB } from "../../shared/internal";
-import type { DB } from "../generated/kysely-tailordb";
-
-export interface ${inputType} {
-  // TODO: define input fields
-}
-
-export async function run(db: ReadonlyDB<DB>, input: ${inputType}) {
-  // TODO: implement
-  return {};
-}
-`;
-}
-function generateQueryTestStub(doc) {
-  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
-  const inputType = `${pascal}Input`;
-  return `import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
-import type { DB } from "../generated/kysely-tailordb";
-import { run, type ${inputType} } from "./${doc.commandName}";
-
-describe("${doc.commandName}", () => {
-  it("should be implemented", async () => {
-    const { db } = createMockDb<DB>();
-    const result = await run(db, {} as ${inputType});
-    expect(result).toBeDefined();
-  });
-});
-`;
-}
-function generatePermissions(moduleName, commandNames) {
-  const sorted = [...commandNames].sort();
-  const entries = sorted.map((name) => `  "${name}",`).join("\n");
-  return `// @generated \u2014 do not edit
-import { definePermissions } from "../../shared/internal";
-
-export const { permissions, own, all } = definePermissions("${moduleName}", [
-${entries}
-] as const);
-`;
-}
-function runGenerateCode(modulePath, moduleName) {
-  const docsDir = path7.join(modulePath, "docs", "commands");
-  const libDir = path7.join(modulePath, "lib");
-  const commandDir = path7.join(modulePath, "command");
-  if (!fs5.existsSync(docsDir)) {
-    console.error(`No docs/commands/ directory found at ${docsDir}`);
-    return 1;
-  }
-  const mdFiles = fs5.readdirSync(docsDir).filter((f) => f.endsWith(".md"));
-  if (mdFiles.length === 0) {
-    console.error(`No command docs found in ${docsDir}`);
-    return 1;
-  }
-  const parsedDocs = [];
-  for (const file of mdFiles) {
-    const content = fs5.readFileSync(path7.join(docsDir, file), "utf-8");
-    const name = path7.basename(file, ".md");
-    parsedDocs.push(parseCommandDoc(name, content));
-  }
-  const queryDocsDir = path7.join(modulePath, "docs", "queries");
-  const allDocsForErrors = [...parsedDocs];
-  if (fs5.existsSync(queryDocsDir)) {
-    const queryFiles = fs5.readdirSync(queryDocsDir).filter((f) => f.endsWith(".md"));
-    for (const file of queryFiles) {
-      const content = fs5.readFileSync(path7.join(queryDocsDir, file), "utf-8");
-      const name = path7.basename(file, ".md");
-      allDocsForErrors.push(parseCommandDoc(name, content));
-    }
-  }
-  let generated = 0;
-  const errorsContent = generateErrors(allDocsForErrors);
-  if (errorsContent) {
-    fs5.mkdirSync(libDir, { recursive: true });
-    const errorsFile = path7.join(libDir, "errors.generated.ts");
-    fs5.writeFileSync(errorsFile, errorsContent);
-    console.log(`  wrote ${path7.relative(modulePath, errorsFile)}`);
-    generated++;
-  }
-  const commandNames = parsedDocs.map((d) => d.commandName);
-  const permissionsContent = generatePermissions(moduleName, commandNames);
-  const permissionsFile = path7.join(libDir, "permissions.generated.ts");
-  fs5.writeFileSync(permissionsFile, permissionsContent);
-  console.log(`  wrote ${path7.relative(modulePath, permissionsFile)}`);
-  generated++;
-  fs5.mkdirSync(commandDir, { recursive: true });
-  for (const doc of parsedDocs) {
-    const implFile = path7.join(commandDir, `${doc.commandName}.ts`);
-    const shellContent = generateCommandShell(doc);
-    const shellFile = path7.join(commandDir, `${doc.commandName}.generated.ts`);
-    fs5.writeFileSync(shellFile, shellContent);
-    console.log(`  wrote ${path7.relative(modulePath, shellFile)}`);
-    generated++;
-    if (!fs5.existsSync(implFile)) {
-      fs5.writeFileSync(implFile, generateCommandStub(doc));
-      console.log(`  scaffolded ${path7.relative(modulePath, implFile)}`);
-    }
-    const testFile = path7.join(commandDir, `${doc.commandName}.test.ts`);
-    if (!fs5.existsSync(testFile)) {
-      fs5.writeFileSync(testFile, generateTestStub(doc));
-      console.log(`  scaffolded ${path7.relative(modulePath, testFile)}`);
-    }
-  }
-  if (fs5.existsSync(queryDocsDir)) {
-    const queryFiles = fs5.readdirSync(queryDocsDir).filter((f) => f.endsWith(".md"));
-    if (queryFiles.length > 0) {
-      const queryDir = path7.join(modulePath, "query");
-      fs5.mkdirSync(queryDir, { recursive: true });
-      for (const file of queryFiles) {
-        const content = fs5.readFileSync(path7.join(queryDocsDir, file), "utf-8");
-        const name = path7.basename(file, ".md");
-        const doc = parseCommandDoc(name, content);
-        const shellFile = path7.join(queryDir, `${doc.commandName}.generated.ts`);
-        fs5.writeFileSync(shellFile, generateQueryShell(doc));
-        console.log(`  wrote ${path7.relative(modulePath, shellFile)}`);
-        generated++;
-        const implFile = path7.join(queryDir, `${doc.commandName}.ts`);
-        if (!fs5.existsSync(implFile)) {
-          fs5.writeFileSync(implFile, generateQueryStub(doc));
-          console.log(`  scaffolded ${path7.relative(modulePath, implFile)}`);
-        }
-        const testFile = path7.join(queryDir, `${doc.commandName}.test.ts`);
-        if (!fs5.existsSync(testFile)) {
-          fs5.writeFileSync(testFile, generateQueryTestStub(doc));
-          console.log(`  scaffolded ${path7.relative(modulePath, testFile)}`);
-        }
-      }
-    }
-  }
-  console.log(`Generated ${generated} file(s) for ${moduleName}`);
-  return 0;
-}
-
-// src/commands/module/generate.ts
-var cwd = process.cwd();
-var codeCommand = defineCommand({
-  name: "code",
-  description: "Generate errors, permissions, command shells, and query shells from docs",
-  args: z.object({
-    root: arg(z.string(), {
-      alias: "r",
-      description: "Path to modules directory"
-    }),
-    module: arg(z.string(), {
-      positional: true,
-      description: "Module name (e.g., primitives, item-management)"
-    })
-  }),
-  run: (args) => {
-    const modulePath = path8.resolve(cwd, args.root, args.module);
-    console.log(`Generating code for ${args.module}...`);
-    const exitCode = runGenerateCode(modulePath, args.module);
-    process.exit(exitCode);
-  }
-});
-var generateCommand = defineCommand({
-  name: "generate",
-  description: "Generate code from model definitions and docs",
-  subCommands: {
-    code: codeCommand
-  }
-});
-
-// src/commands/module/index.ts
-var cwd2 = process.cwd();
-var rootArgs = z2.object({
-  root: arg2(z2.string(), {
-    alias: "r",
-    description: "Path to modules directory"
-  })
-});
-var listCommand = defineCommand2({
-  name: "list",
-  description: "List available modules",
-  run: () => {
-    const exitCode = runModuleList();
-    process.exit(exitCode);
-  }
-});
-var checkCommand = defineCommand2({
-  name: "check",
-  description: "Validate module docs against schemas",
-  args: rootArgs,
-  run: async (args) => {
-    const exitCode = await runCheck({ modulesRoot: args.root }, cwd2);
-    process.exit(exitCode);
-  }
-});
-var syncCheckCommand = defineCommand2({
-  name: "sync-check",
-  description: "Validate source <-> doc correspondence",
-  args: rootArgs,
-  run: async (args) => {
-    const result = await runSyncCheck({ modulesRoot: args.root }, cwd2);
-    console.log(formatSyncCheckReport(result));
-    process.exit(result.exitCode);
-  }
-});
-var scaffoldCommand = defineCommand2({
-  name: "scaffold",
-  description: "Generate module doc from schema template",
-  args: rootArgs.extend({
-    type: arg2(z2.enum(MODULE_TYPES), {
-      positional: true,
-      description: `Scaffold type (${MODULE_TYPES.join(", ")})`
-    }),
-    parent: arg2(z2.string(), {
-      positional: true,
-      description: "Module name"
-    }),
-    name: arg2(z2.string().optional(), {
-      positional: true,
-      description: "Item name (required for feature, command, model)"
-    })
-  }),
-  run: async (args) => {
-    const exitCode = await runScaffold(
-      args.type,
-      args.parent,
-      args.name,
-      args.root,
-      cwd2
-    );
-    process.exit(exitCode);
-  }
-});
-var moduleCommand = defineCommand2({
-  name: "module",
-  description: "Module management",
-  subCommands: {
-    list: listCommand,
-    check: checkCommand,
-    "sync-check": syncCheckCommand,
-    scaffold: scaffoldCommand,
-    generate: generateCommand
-  }
-});
-
-// src/commands/app/index.ts
-import { z as z3 } from "zod";
-import { defineCommand as defineCommand3, arg as arg3 } from "politty";
-var cwd3 = process.cwd();
-var rootArgs2 = z3.object({
-  root: arg3(z3.string(), {
-    alias: "r",
-    description: "Path to app-compose directory"
-  })
-});
-var checkCommand2 = defineCommand3({
-  name: "check",
-  description: "Validate app docs against schemas",
-  args: rootArgs2,
-  run: async (args) => {
-    const exitCode = await runCheck({ appRoot: args.root }, cwd3);
-    process.exit(exitCode);
-  }
-});
-var syncCheckCommand2 = defineCommand3({
-  name: "sync-check",
-  description: "Validate source <-> doc correspondence",
-  args: rootArgs2,
-  run: async (args) => {
-    const result = await runSyncCheck({ appRoot: args.root }, cwd3);
-    console.log(formatSyncCheckReport(result));
-    process.exit(result.exitCode);
-  }
-});
-var scaffoldCommand2 = defineCommand3({
-  name: "scaffold",
-  description: "Generate app doc from schema template",
-  args: rootArgs2.extend({
-    type: arg3(z3.enum(APP_TYPES), {
-      positional: true,
-      description: `Scaffold type (${APP_TYPES.join(", ")})`
-    }),
-    parent: arg3(z3.string(), {
-      positional: true,
-      description: "App name"
-    }),
-    name: arg3(z3.string().optional(), {
-      positional: true,
-      description: "Item name (required for most types)"
-    })
-  }),
-  run: async (args) => {
-    const exitCode = await runScaffold(
-      args.type,
-      args.parent,
-      args.name,
-      args.root,
-      cwd3
-    );
-    process.exit(exitCode);
-  }
-});
-var appCommand = defineCommand3({
-  name: "app",
-  description: "App-compose management",
-  subCommands: {
-    check: checkCommand2,
-    "sync-check": syncCheckCommand2,
-    scaffold: scaffoldCommand2
-  }
-});
-
-// src/commands/mock/index.ts
-import { z as z4 } from "zod";
-import { defineCommand as defineCommand4, arg as arg4 } from "politty";
-
-// src/commands/mock/start.ts
-import { createServer, request as httpRequest } from "http";
-import { createServer as createNetServer } from "net";
-import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
-import { resolve as resolve2, relative, join as join2 } 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 readdirSync2(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 = join2(mocksDir, provider);
-    for (const scenario of readdirSafe(providerDir)) {
-      const mockPath = join2(providerDir, scenario, "mock.json");
-      if (!existsSync2(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 join3, resolve as resolve3, relative as relative2, dirname as dirname2, basename } from "path";
-import chalk4 from "chalk";
-function pass(msg) {
-  console.log(chalk4.green(`\u2713 ${msg}`));
-}
-function fail(ctx, msg) {
-  console.log(chalk4.red(`\u2717 ${msg}`));
-  ctx.failures++;
-}
-async function subdirs(dir) {
-  const entries = await readdir(dir);
-  const dirs = [];
-  for (const entry of entries) {
-    const full = join3(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 = join3(mocksDir, provider);
-    for (const scenario of await subdirs(providerDir)) {
-      scenarios.push(`${provider}/${scenario}`);
-    }
-  }
-  return scenarios;
-}
-function resolveScenarioDir(arg6) {
-  const abs = resolve3(arg6);
-  if (basename(abs) === "mock.json") return dirname2(abs);
-  return abs;
-}
-async function validateScenario(ctx, scenarioDir, mocksDir) {
-  const label = relative2(mocksDir, scenarioDir);
-  console.log(chalk4.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 = join3(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) => join3(mocksDir, s));
-  if (targets.length === 0) {
-    fail(ctx, "No scenarios found under mocks/");
-    return 1;
-  }
-  console.log(chalk4.bold("\nValidating mock configs...\n"));
-  for (const target of targets) {
-    await validateScenario(ctx, target, mocksDir);
-  }
-  console.log(chalk4.bold("\n\u2500\u2500 summary \u2500\u2500"));
-  if (ctx.failures === 0) {
-    console.log(chalk4.green("\u2713 All checks passed"));
-  } else {
-    console.log(chalk4.red(`\u2717 ${ctx.failures} check(s) failed`));
-  }
-  return ctx.failures === 0 ? 0 : 1;
-}
-
-// src/commands/mock/index.ts
-var startCommand = defineCommand4({
-  name: "start",
-  description: "Start mock API servers with reverse proxy",
-  args: z4.object({
-    mocksRoot: arg4(z4.string().default("./mocks"), {
-      description: "Path to mocks directory"
-    }),
-    port: arg4(z4.coerce.number().default(3e3), {
-      alias: "p",
-      description: "Reverse proxy port"
-    }),
-    filter: arg4(z4.array(z4.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 = defineCommand4({
-  name: "validate",
-  description: "Validate mock scenario configs",
-  args: z4.object({
-    mocksRoot: arg4(z4.string().default("./mocks"), {
-      description: "Path to mocks directory"
-    }),
-    paths: arg4(z4.array(z4.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 = defineCommand4({
-  name: "mock",
-  description: "Mock API server management",
-  subCommands: {
-    start: startCommand,
-    validate: validateCommand
-  }
-});
-
-// src/commands/index.ts
-var cwd4 = process.cwd();
-var initCommand = defineCommand5({
-  name: "init",
-  description: "Set up consumer repo with framework skills",
-  args: z5.object({
-    force: arg5(z5.boolean().default(false), {
-      alias: "f",
-      description: "Overwrite existing skills"
-    })
-  }),
-  run: (args) => {
-    const exitCode = runInit(cwd4, args.force);
-    process.exit(exitCode);
-  }
-});
-var licenseCheckCommand = defineCommand5({
-  name: "check",
-  description: "Check dependency licenses against allowlist",
-  args: z5.object({
-    config: arg5(z5.string(), {
-      alias: "c",
-      description: "Path to license config JSON file"
-    })
-  }),
-  run: (args) => {
-    const exitCode = runLicenseCheck(args.config);
-    process.exit(exitCode);
-  }
-});
-var licenseListCommand = defineCommand5({
-  name: "list",
-  description: "List available license groups",
-  run: () => {
-    const exitCode = runLicenseList();
-    process.exit(exitCode);
-  }
-});
-var licenseCommand = defineCommand5({
-  name: "license",
-  description: "License management",
-  subCommands: {
-    check: licenseCheckCommand,
-    list: licenseListCommand
-  }
-});
-var mainCommand = defineCommand5({
-  name: "erp-kit",
-  description: "ERP module framework CLI",
-  subCommands: {
-    module: moduleCommand,
-    app: appCommand,
-    mock: mockCommand,
-    init: initCommand,
-    license: licenseCommand
-  }
-});
-
-// src/cli.ts
-void runMain(mainCommand);