@tailor-platform/erp-kit 0.1.2 → 0.2.1

package/dist/cli.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { z as z4 } from "zod";
-import { defineCommand as defineCommand4, runMain, arg as arg4 } from "politty";
+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";
@@ -15,20 +18,10 @@ var PACKAGE_ROOT = path.resolve(import.meta.dirname, "..");
 
 // src/commands/init.ts
 var SKILLS_SRC = path2.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 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;
@@ -51,12 +44,25 @@ function copyDirectoryRecursive(srcDir, destDir, force) {
   }
   return { copied, skipped };
 }
-function runInit(cwd4, force) {
+function runInit(cwd5, force) {
   console.log(chalk.bold("erp-kit init\n"));
-  const skillsDest = path2.join(cwd4, ".agents", "skills");
+  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;
-  for (const skill of FRAMEWORK_SKILLS) {
+  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);
@@ -73,7 +79,7 @@ function runInit(cwd4, force) {
       chalk.yellow(`  Skipped ${skippedCount} existing files (use --force to overwrite)`)
     );
   }
-  const claudeSkills = path2.join(cwd4, ".claude", "skills");
+  const claudeSkills = path2.join(cwd5, ".claude", "skills");
   const relTarget = path2.relative(path2.dirname(claudeSkills), skillsDest);
   const claudeSkillsExists = (() => {
     try {
@@ -110,376 +116,169 @@ function runInit(cwd4, force) {
   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 });
+// 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 (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)}/`);
+  if (config.allow) {
+    for (const license of config.allow) {
+      set.add(license);
     }
-    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();
+  if (config.deny) {
+    for (const license of config.deny) {
+      set.delete(license);
     }
-    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 chalk2 from "chalk";
-function pass(msg) {
-  console.log(chalk2.green(`\u2713 ${msg}`));
-}
-function fail(ctx, msg) {
-  console.log(chalk2.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();
+  return set;
 }
-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;
+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));
   }
-  fail(ctx, `${label}: missing mock.json`);
-  return false;
+  return allowSet.has(licenseString);
 }
-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 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 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 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;
     }
   }
-}
-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`);
-        }
+  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 });
       }
     }
   }
-}
-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}`);
-    }
+  if (violations.length === 0) {
+    console.log("All licenses are allowed.");
+    return 0;
   }
-  return scenarios;
+  console.error("Found dependencies with disallowed licenses:\n");
+  for (const violation of violations) {
+    console.error(`  - ${violation.package}`);
+    console.error(`    License: ${violation.license}
+`);
+  }
+  return 1;
 }
-function resolveScenarioDir(arg5) {
-  const abs = resolve3(arg5);
-  if (basename(abs) === "mock.json") return dirname2(abs);
-  return abs;
-}
-async function validateScenario(ctx, scenarioDir, mocksDir) {
-  const label = relative2(mocksDir, scenarioDir);
-  console.log(chalk2.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(chalk2.bold("\nValidating mock configs...\n"));
-  for (const target of targets) {
-    await validateScenario(ctx, target, mocksDir);
-  }
-  console.log(chalk2.bold("\n\u2500\u2500 summary \u2500\u2500"));
-  if (ctx.failures === 0) {
-    console.log(chalk2.green("\u2713 All checks passed"));
-  } else {
-    console.log(chalk2.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/commands/module/index.ts
 import { z as z2 } from "zod";
@@ -487,25 +286,25 @@ import { defineCommand as defineCommand2, arg as arg2 } from "politty";
 
 // src/mdschema.ts
 import path3 from "path";
-import fs2 from "fs";
+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(fs2.readFileSync(pkgPath, "utf-8"));
+  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, cwd4) {
+function runMdschema(args, cwd5) {
   return new Promise((resolve4) => {
     execFile(
       getMdschemaBin(),
       args,
-      { encoding: "utf-8", cwd: cwd4, timeout: 3e4 },
+      { encoding: "utf-8", cwd: cwd5, timeout: 3e4 },
       (error, stdout, stderr) => {
         if (error) {
           const execError = error;
@@ -571,7 +370,7 @@ function buildCheckTargets(config) {
   }
   return targets;
 }
-async function runCheck(config, cwd4) {
+async function runCheck(config, cwd5) {
   const targets = buildCheckTargets(config);
   const results = await Promise.all(
     targets.map(async (target) => {
@@ -582,7 +381,7 @@ async function runCheck(config, cwd4) {
       }
       const { exitCode, stdout, stderr } = await runMdschema(
         ["check", target.glob, "--schema", schemaPath],
-        cwd4
+        cwd5
       );
       if (stdout.trim()) console.log(stdout);
       if (stderr.trim()) console.error(stderr);
@@ -596,14 +395,14 @@ async function runCheck(config, cwd4) {
 // src/commands/sync-check.ts
 import path5 from "path";
 import fg from "fast-glob";
-import chalk3 from "chalk";
+import chalk2 from "chalk";
 function moduleCategories(root) {
   return [
     {
       name: "command",
       sourcePattern: `${root}/*/command/*.ts`,
       docPattern: `${root}/*/docs/commands/*.md`,
-      exclusions: [/\.test\.ts$/]
+      exclusions: [/\.test\.ts$/, /\.generated\.ts$/]
     },
     {
       name: "model",
@@ -632,7 +431,7 @@ function appComposeCategories(root) {
 function shouldExclude(fileName, exclusions) {
   return exclusions.some((pattern) => pattern.test(fileName));
 }
-async function runSyncCheck(config, cwd4) {
+async function runSyncCheck(config, cwd5) {
   const errors = [];
   let totalSources = 0;
   let totalDocs = 0;
@@ -644,14 +443,17 @@ async function runSyncCheck(config, cwd4) {
     allCategories.push(...appComposeCategories(config.appRoot));
   }
   for (const category of allCategories) {
-    const sources = await fg(category.sourcePattern, { cwd: cwd4 });
-    const docs = await fg(category.docPattern, { cwd: cwd4 });
+    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;
-      const basename2 = path5.basename(sourcePath, path5.extname(sourcePath));
+      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) {
@@ -693,9 +495,9 @@ async function runSyncCheck(config, cwd4) {
 }
 function formatSyncCheckReport(result) {
   const lines = [];
-  lines.push(chalk3.bold("docs-sync-check: Checking source-documentation correspondence...\n"));
+  lines.push(chalk2.bold("docs-sync-check: Checking source-documentation correspondence...\n"));
   if (result.errors.length > 0) {
-    lines.push(chalk3.red.bold("Errors:\n"));
+    lines.push(chalk2.red.bold("Errors:\n"));
     const byCategory = /* @__PURE__ */ new Map();
     for (const error of result.errors) {
       const existing = byCategory.get(error.category) ?? [];
@@ -703,44 +505,104 @@ function formatSyncCheckReport(result) {
       byCategory.set(error.category, existing);
     }
     for (const [category, categoryErrors] of byCategory) {
-      lines.push(chalk3.cyan(`  Category: ${category}
+      lines.push(chalk2.cyan(`  Category: ${category}
 `));
       for (const error of categoryErrors) {
         if (error.type === "missing-doc") {
-          lines.push(`  ${chalk3.red(error.sourcePath)}`);
-          lines.push(`    ${chalk3.yellow("Missing documentation for:")} ${error.expectedBasename}`);
+          lines.push(`  ${chalk2.red(error.sourcePath)}`);
+          lines.push(`    ${chalk2.yellow("Missing documentation for:")} ${error.expectedBasename}`);
         } else {
-          lines.push(`  ${chalk3.red(error.docPath)}`);
+          lines.push(`  ${chalk2.red(error.docPath)}`);
           lines.push(
-            `    ${chalk3.yellow("Orphaned documentation:")} no source file for ${error.expectedBasename}`
+            `    ${chalk2.yellow("Orphaned documentation:")} no source file for ${error.expectedBasename}`
           );
         }
         lines.push("");
       }
     }
   } else {
-    lines.push(chalk3.green("All source files have corresponding documentation.\n"));
+    lines.push(chalk2.green("All source files have corresponding documentation.\n"));
   }
-  lines.push(chalk3.bold("Summary:"));
+  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(chalk3.red(`  Errors: ${result.errors.length}`));
+    lines.push(chalk2.red(`  Errors: ${result.errors.length}`));
     lines.push("");
-    lines.push(chalk3.red.bold(`docs-sync-check failed with ${result.errors.length} error(s).`));
+    lines.push(chalk2.red.bold(`docs-sync-check failed with ${result.errors.length} error(s).`));
   } else {
-    lines.push(chalk3.green("  Errors: 0"));
+    lines.push(chalk2.green("  Errors: 0"));
     lines.push("");
-    lines.push(chalk3.green.bold("docs-sync-check passed."));
+    lines.push(chalk2.green.bold("docs-sync-check passed."));
   }
   return lines.join("\n");
 }
 
 // src/commands/scaffold.ts
 import path6 from "path";
-import fs3 from "fs";
+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",
@@ -790,10 +652,10 @@ function resolveScaffoldPath(type, parentName, name, root) {
   }
   throw new Error(`Unknown scaffold type: ${type}`);
 }
-async function runScaffold(type, parentName, name, root, cwd4) {
+async function runScaffold(type, parentName, name, root, cwd5) {
   const outputPath = resolveScaffoldPath(type, parentName, name, root);
-  const absoluteOutput = path6.resolve(cwd4, outputPath);
-  if (fs3.existsSync(absoluteOutput)) {
+  const absoluteOutput = path6.resolve(cwd5, outputPath);
+  if (fs4.existsSync(absoluteOutput)) {
     console.error(`File already exists: ${outputPath}`);
     return 1;
   }
@@ -803,7 +665,7 @@ async function runScaffold(type, parentName, name, root, cwd4) {
     return 2;
   }
   try {
-    fs3.mkdirSync(path6.dirname(absoluteOutput), { recursive: true });
+    fs4.mkdirSync(path6.dirname(absoluteOutput), { recursive: true });
   } catch (err) {
     console.error(
       `Failed to create directory: ${err instanceof Error ? err.message : String(err)}`
@@ -812,39 +674,55 @@ async function runScaffold(type, parentName, name, root, cwd4) {
   }
   const { exitCode, stdout, stderr } = await runMdschema(
     ["generate", "--schema", schemaPath, "--output", absoluteOutput],
-    cwd4
+    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 as readdirSync2, existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
-import chalk4 from "chalk";
-var MODULES_DIR = join3(PACKAGE_ROOT, "src", "modules");
+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 (!existsSync2(dir)) return 0;
-  return readdirSync2(dir).filter((f) => pattern.test(f) && !exclusions.some((p) => p.test(f))).length;
+  if (!existsSync(dir)) return 0;
+  return readdirSync(dir).filter((f) => pattern.test(f) && !exclusions.some((p) => p.test(f))).length;
 }
 function listModules() {
-  if (!existsSync2(MODULES_DIR)) return [];
-  return readdirSync2(MODULES_DIR, { withFileTypes: true }).filter((d) => d.isDirectory() && !EXCLUDED_DIRS.has(d.name)).map((d) => {
-    const modDir = join3(MODULES_DIR, d.name);
+  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(join3(modDir, "command"), /\.ts$/, [/\.test\.ts$/]),
-      models: countFiles(join3(modDir, "db"), /\.ts$/, [/\.test\.ts$/, /^index\.ts$/]),
-      features: countFiles(join3(modDir, "docs", "features"), /\.md$/, [])
+      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(chalk4.bold("Modules:\n"));
+  lines.push(chalk3.bold("Modules:\n"));
   const nameWidth = Math.max(...modules.map((m) => m.name.length), 4);
   for (const mod of modules) {
     const counts = [
@@ -864,8 +742,345 @@ function runModuleList() {
   return 0;
 }
 
-// src/commands/module/index.ts
+// 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",
@@ -885,7 +1100,7 @@ var checkCommand = defineCommand2({
   description: "Validate module docs against schemas",
   args: rootArgs,
   run: async (args) => {
-    const exitCode = await runCheck({ modulesRoot: args.root }, cwd);
+    const exitCode = await runCheck({ modulesRoot: args.root }, cwd2);
     process.exit(exitCode);
   }
 });
@@ -894,7 +1109,7 @@ var syncCheckCommand = defineCommand2({
   description: "Validate source <-> doc correspondence",
   args: rootArgs,
   run: async (args) => {
-    const result = await runSyncCheck({ modulesRoot: args.root }, cwd);
+    const result = await runSyncCheck({ modulesRoot: args.root }, cwd2);
     console.log(formatSyncCheckReport(result));
     process.exit(result.exitCode);
   }
@@ -922,7 +1137,7 @@ var scaffoldCommand = defineCommand2({
       args.parent,
       args.name,
       args.root,
-      cwd
+      cwd2
     );
     process.exit(exitCode);
   }
@@ -934,14 +1149,15 @@ var moduleCommand = defineCommand2({
     list: listCommand,
     check: checkCommand,
     "sync-check": syncCheckCommand,
-    scaffold: scaffoldCommand
+    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 cwd2 = process.cwd();
+var cwd3 = process.cwd();
 var rootArgs2 = z3.object({
   root: arg3(z3.string(), {
     alias: "r",
@@ -953,7 +1169,7 @@ var checkCommand2 = defineCommand3({
   description: "Validate app docs against schemas",
   args: rootArgs2,
   run: async (args) => {
-    const exitCode = await runCheck({ appRoot: args.root }, cwd2);
+    const exitCode = await runCheck({ appRoot: args.root }, cwd3);
     process.exit(exitCode);
   }
 });
@@ -962,7 +1178,7 @@ var syncCheckCommand2 = defineCommand3({
   description: "Validate source <-> doc correspondence",
   args: rootArgs2,
   run: async (args) => {
-    const result = await runSyncCheck({ appRoot: args.root }, cwd2);
+    const result = await runSyncCheck({ appRoot: args.root }, cwd3);
     console.log(formatSyncCheckReport(result));
     process.exit(result.exitCode);
   }
@@ -990,7 +1206,7 @@ var scaffoldCommand2 = defineCommand3({
       args.parent,
       args.name,
       args.root,
-      cwd2
+      cwd3
     );
     process.exit(exitCode);
   }
@@ -1005,30 +1221,434 @@ var appCommand = defineCommand3({
   }
 });
 
-// src/cli.ts
-var cwd3 = process.cwd();
-var initCommand = defineCommand4({
-  name: "init",
-  description: "Set up consumer repo with framework skills",
-  args: z4.object({
-    force: arg4(z4.boolean().default(false), {
-      alias: "f",
-      description: "Overwrite existing skills"
-    })
-  }),
-  run: (args) => {
-    const exitCode = runInit(cwd3, args.force);
-    process.exit(exitCode);
-  }
-});
-var main = defineCommand4({
-  name: "erp-kit",
-  description: "ERP module framework CLI",
-  subCommands: {
-    module: moduleCommand,
-    app: appCommand,
-    mock: mockCommand,
-    init: initCommand
+// 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;
   }
-});
-void runMain(main);
+  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);