@tailor-platform/erp-kit 0.1.1 → 0.2.0

package/dist/cli.js

@@ -1,30 +1,310 @@
 #!/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, runMain, arg as arg2 } from "politty";
+import { defineCommand as defineCommand2, arg as arg2 } from "politty";
 
 // src/mdschema.ts
-import path from "path";
-import fs from "fs";
+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(fs.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 path.join(path.dirname(pkgPath), bin);
+  return path3.join(path3.dirname(pkgPath), bin);
 }
-function runMdschema(args, cwd2) {
+function runMdschema(args, cwd5) {
   return new Promise((resolve4) => {
     execFile(
       getMdschemaBin(),
       args,
-      { encoding: "utf-8", cwd: cwd2, timeout: 3e4 },
+      { encoding: "utf-8", cwd: cwd5, timeout: 3e4 },
       (error, stdout, stderr) => {
         if (error) {
           const execError = error;
@@ -42,27 +322,22 @@ function runMdschema(args, cwd2) {
 }
 
 // src/schemas.ts
-import path3 from "path";
-
-// src/util.ts
-import path2 from "path";
-var PACKAGE_ROOT = path2.resolve(import.meta.dirname, "..");
-
-// src/schemas.ts
-var SCHEMAS_ROOT = path3.join(PACKAGE_ROOT, "schemas");
+import path4 from "path";
+var SCHEMAS_ROOT = path4.join(PACKAGE_ROOT, "schemas");
 var MODULE_SCHEMAS = {
-  module: path3.join(SCHEMAS_ROOT, "module", "module.yml"),
-  command: path3.join(SCHEMAS_ROOT, "module", "command.yml"),
-  model: path3.join(SCHEMAS_ROOT, "module", "model.yml"),
-  feature: path3.join(SCHEMAS_ROOT, "module", "feature.yml")
+  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: path3.join(SCHEMAS_ROOT, "app-compose", "requirements.yml"),
-  actors: path3.join(SCHEMAS_ROOT, "app-compose", "actors.yml"),
-  "business-flow": path3.join(SCHEMAS_ROOT, "app-compose", "business-flow.yml"),
-  story: path3.join(SCHEMAS_ROOT, "app-compose", "story.yml"),
-  screen: path3.join(SCHEMAS_ROOT, "app-compose", "screen.yml"),
-  resolver: path3.join(SCHEMAS_ROOT, "app-compose", "resolver.yml")
+  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,
@@ -78,6 +353,7 @@ function buildCheckTargets(config) {
       { 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" }
     );
   }
@@ -94,7 +370,7 @@ function buildCheckTargets(config) {
   }
   return targets;
 }
-async function runCheck(config, cwd2) {
+async function runCheck(config, cwd5) {
   const targets = buildCheckTargets(config);
   const results = await Promise.all(
     targets.map(async (target) => {
@@ -105,7 +381,7 @@ async function runCheck(config, cwd2) {
       }
       const { exitCode, stdout, stderr } = await runMdschema(
         ["check", target.glob, "--schema", schemaPath],
-        cwd2
+        cwd5
       );
       if (stdout.trim()) console.log(stdout);
       if (stderr.trim()) console.error(stderr);
@@ -117,22 +393,28 @@ async function runCheck(config, cwd2) {
 }
 
 // src/commands/sync-check.ts
-import path4 from "path";
+import path5 from "path";
 import fg from "fast-glob";
-import chalk 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",
       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$/]
     }
   ];
 }
@@ -149,7 +431,7 @@ function appComposeCategories(root) {
 function shouldExclude(fileName, exclusions) {
   return exclusions.some((pattern) => pattern.test(fileName));
 }
-async function runSyncCheck(config, cwd2) {
+async function runSyncCheck(config, cwd5) {
   const errors = [];
   let totalSources = 0;
   let totalDocs = 0;
@@ -161,18 +443,21 @@ async function runSyncCheck(config, cwd2) {
     allCategories.push(...appComposeCategories(config.appRoot));
   }
   for (const category of allCategories) {
-    const sources = await fg(category.sourcePattern, { cwd: cwd2 });
-    const docs = await fg(category.docPattern, { cwd: cwd2 });
+    const 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 = path4.basename(sourcePath);
+      const fileName = path5.basename(sourcePath);
       if (shouldExclude(fileName, category.exclusions)) continue;
-      const basename2 = path4.basename(sourcePath, path4.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) {
-      const basename2 = path4.basename(docPath, path4.extname(docPath));
+      const basename2 = path5.basename(docPath, path5.extname(docPath));
       docBasenames.set(basename2.toLowerCase(), docPath);
     }
     for (const [basename2, sourcePath] of sourceBasenames) {
@@ -210,9 +495,9 @@ async function runSyncCheck(config, cwd2) {
 }
 function formatSyncCheckReport(result) {
   const lines = [];
-  lines.push(chalk.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(chalk.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) ?? [];
@@ -220,45 +505,105 @@ function formatSyncCheckReport(result) {
       byCategory.set(error.category, existing);
     }
     for (const [category, categoryErrors] of byCategory) {
-      lines.push(chalk.cyan(`  Category: ${category}
+      lines.push(chalk2.cyan(`  Category: ${category}
 `));
       for (const error of categoryErrors) {
         if (error.type === "missing-doc") {
-          lines.push(`  ${chalk.red(error.sourcePath)}`);
-          lines.push(`    ${chalk.yellow("Missing documentation for:")} ${error.expectedBasename}`);
+          lines.push(`  ${chalk2.red(error.sourcePath)}`);
+          lines.push(`    ${chalk2.yellow("Missing documentation for:")} ${error.expectedBasename}`);
         } else {
-          lines.push(`  ${chalk.red(error.docPath)}`);
+          lines.push(`  ${chalk2.red(error.docPath)}`);
           lines.push(
-            `    ${chalk.yellow("Orphaned documentation:")} no source file for ${error.expectedBasename}`
+            `    ${chalk2.yellow("Orphaned documentation:")} no source file for ${error.expectedBasename}`
           );
         }
         lines.push("");
       }
     }
   } else {
-    lines.push(chalk.green("All source files have corresponding documentation.\n"));
+    lines.push(chalk2.green("All source files have corresponding documentation.\n"));
   }
-  lines.push(chalk.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(chalk.red(`  Errors: ${result.errors.length}`));
+    lines.push(chalk2.red(`  Errors: ${result.errors.length}`));
     lines.push("");
-    lines.push(chalk.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(chalk.green("  Errors: 0"));
+    lines.push(chalk2.green("  Errors: 0"));
     lines.push("");
-    lines.push(chalk.green.bold("docs-sync-check passed."));
+    lines.push(chalk2.green.bold("docs-sync-check passed."));
   }
   return lines.join("\n");
 }
 
 // src/commands/scaffold.ts
-import path5 from "path";
-import fs2 from "fs";
-var MODULE_TYPES = ["module", "feature", "command", "model"];
+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",
@@ -271,7 +616,8 @@ var ALL_TYPES = [...MODULE_TYPES, ...APP_TYPES];
 var MODULE_DIR_MAP = {
   feature: "docs/features",
   command: "docs/commands",
-  model: "docs/models"
+  model: "docs/models",
+  query: "docs/queries"
 };
 var APP_DIR_MAP = {
   actors: "docs/actors",
@@ -279,18 +625,15 @@ var APP_DIR_MAP = {
   screen: "docs/screen",
   resolver: "docs/resolver"
 };
-function isModuleType(type) {
-  return MODULE_TYPES.includes(type);
-}
 function resolveScaffoldPath(type, parentName, name, root) {
   if (type === "module" || type === "requirements") {
-    return path5.join(root, parentName, "README.md");
+    return path6.join(root, parentName, "README.md");
   }
   if (!name) {
     throw new Error(`Name is required for scaffold type "${type}"`);
   }
   if (type === "business-flow") {
-    return path5.join(root, parentName, "docs/business-flow", name, "README.md");
+    return path6.join(root, parentName, "docs/business-flow", name, "README.md");
   }
   if (type === "story") {
     const parts = name.split("/");
@@ -299,20 +642,20 @@ function resolveScaffoldPath(type, parentName, name, root) {
         `Story name must be "<flow>/<story>" (e.g., "onboarding/admin--create-user")`
       );
     }
-    return path5.join(root, parentName, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
+    return path6.join(root, parentName, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
   }
   if (MODULE_DIR_MAP[type]) {
-    return path5.join(root, parentName, MODULE_DIR_MAP[type], `${name}.md`);
+    return path6.join(root, parentName, MODULE_DIR_MAP[type], `${name}.md`);
   }
   if (APP_DIR_MAP[type]) {
-    return path5.join(root, parentName, APP_DIR_MAP[type], `${name}.md`);
+    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, cwd2) {
+async function runScaffold(type, parentName, name, root, cwd5) {
   const outputPath = resolveScaffoldPath(type, parentName, name, root);
-  const absoluteOutput = path5.resolve(cwd2, outputPath);
-  if (fs2.existsSync(absoluteOutput)) {
+  const absoluteOutput = path6.resolve(cwd5, outputPath);
+  if (fs4.existsSync(absoluteOutput)) {
     console.error(`File already exists: ${outputPath}`);
     return 1;
   }
@@ -322,7 +665,7 @@ async function runScaffold(type, parentName, name, root, cwd2) {
     return 2;
   }
   try {
-    fs2.mkdirSync(path5.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)}`
@@ -331,122 +674,562 @@ async function runScaffold(type, parentName, name, root, cwd2) {
   }
   const { exitCode, stdout, stderr } = await runMdschema(
     ["generate", "--schema", schemaPath, "--output", absoluteOutput],
-    cwd2
+    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;
 }
-
-// src/commands/init.ts
-import fs3 from "fs";
-import path6 from "path";
-import chalk2 from "chalk";
-var SKILLS_SRC = path6.join(PACKAGE_ROOT, "skills");
-var FRAMEWORK_SKILLS = [
-  "1-module-docs",
-  "2-module-feature-breakdown",
-  "3-module-doc-review",
-  "4-module-tdd-implementation",
-  "5-module-implementation-review",
-  "app-compose-1-requirement-analysis",
-  "app-compose-2-requirements-breakdown",
-  "app-compose-3-doc-review",
-  "app-compose-4-design-mock",
-  "app-compose-5-design-mock-review",
-  "app-compose-6-implementation-spec",
-  "mock-scenario"
-];
-function copyDirectoryRecursive(srcDir, destDir, force) {
-  let copied = 0;
-  let skipped = 0;
-  for (const entry of fs3.readdirSync(srcDir, { withFileTypes: true })) {
-    const srcPath = path6.join(srcDir, entry.name);
-    const destPath = path6.join(destDir, entry.name);
-    if (entry.isDirectory()) {
-      const sub = copyDirectoryRecursive(srcPath, destPath, force);
-      copied += sub.copied;
-      skipped += sub.skipped;
+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 {
-      if (!force && fs3.existsSync(destPath)) {
-        skipped++;
+      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;
       }
-      fs3.mkdirSync(destDir, { recursive: true });
-      fs3.copyFileSync(srcPath, destPath);
-      copied++;
+    }
+    if (collecting) {
+      nodes.push(node);
     }
   }
-  return { copied, skipped };
+  return nodes;
 }
-function runInit(cwd2, force) {
-  console.log(chalk2.bold("erp-kit init\n"));
-  const skillsDest = path6.join(cwd2, ".agents", "skills");
-  let copiedCount = 0;
-  let skippedCount = 0;
-  for (const skill of FRAMEWORK_SKILLS) {
-    const srcSkillDir = path6.join(SKILLS_SRC, skill);
-    if (!fs3.existsSync(srcSkillDir)) continue;
-    const destDir = path6.join(skillsDest, skill);
-    const result = copyDirectoryRecursive(srcSkillDir, destDir, force);
-    copiedCount += result.copied;
-    if (result.skipped > 0) {
-      console.log(chalk2.yellow(`  Skipped ${skill}/ (${result.skipped} existing files)`));
-      skippedCount += result.skipped;
+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() });
+      }
     }
   }
-  console.log(chalk2.green(`  Copied ${copiedCount} skill files to .agents/skills/`));
-  if (skippedCount > 0) {
-    console.log(
-      chalk2.yellow(`  Skipped ${skippedCount} existing files (use --force to overwrite)`)
-    );
+  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] });
+          }
+        }
+      }
+    }
   }
-  const claudeSkills = path6.join(cwd2, ".claude", "skills");
-  const relTarget = path6.relative(path6.dirname(claudeSkills), skillsDest);
-  const claudeSkillsExists = (() => {
-    try {
-      fs3.lstatSync(claudeSkills);
-      return true;
-    } catch {
-      return false;
+  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 (claudeSkillsExists) {
-    const stat2 = fs3.lstatSync(claudeSkills);
-    if (stat2.isSymbolicLink()) {
-      const current = fs3.readlinkSync(claudeSkills);
-      if (current === relTarget) {
-        console.log(chalk2.green("  .claude/skills -> .agents/skills/ (already linked)"));
-      } else if (force) {
-        fs3.unlinkSync(claudeSkills);
-        fs3.symlinkSync(relTarget, claudeSkills);
-        console.log(chalk2.green("  .claude/skills -> .agents/skills/ (relinked)"));
-      } else {
-        console.log(
-          chalk2.yellow(`  Skipped .claude/skills (symlink exists -> ${current}, use --force)`)
-        );
+  }
+  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)}`);
+        }
       }
-    } else {
-      console.log(chalk2.yellow("  Skipped .claude/skills (directory exists, not a symlink)"));
     }
-  } else {
-    fs3.mkdirSync(path6.dirname(claudeSkills), { recursive: true });
-    fs3.symlinkSync(relTarget, claudeSkills);
-    console.log(chalk2.green("  .claude/skills -> .agents/skills/ (linked)"));
   }
-  console.log(chalk2.bold.green("\nDone! Run `erp-kit check` to validate your docs."));
+  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 } from "zod";
-import { defineCommand, arg } from "politty";
+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, readdirSync } from "fs";
-import { resolve as resolve2, relative, join } from "path";
+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";
@@ -489,7 +1272,7 @@ async function createMockServer(mockJsonPath, port) {
 // src/commands/mock/start.ts
 function readdirSafe(dir) {
   try {
-    return readdirSync(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    return readdirSync2(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   } catch {
     return [];
   }
@@ -497,10 +1280,10 @@ function readdirSafe(dir) {
 function discoverMocks(mocksDir, filters) {
   const mocks = [];
   for (const provider of readdirSafe(mocksDir)) {
-    const providerDir = join(mocksDir, provider);
+    const providerDir = join2(mocksDir, provider);
     for (const scenario of readdirSafe(providerDir)) {
-      const mockPath = join(providerDir, scenario, "mock.json");
-      if (!existsSync(mockPath)) continue;
+      const mockPath = join2(providerDir, scenario, "mock.json");
+      if (!existsSync2(mockPath)) continue;
       mocks.push({ provider, scenario, mockPath });
     }
   }
@@ -619,20 +1402,20 @@ Reverse proxy listening on http://localhost:${port}`);
 
 // src/commands/mock/validate.ts
 import { readdir, readFile, stat } from "fs/promises";
-import { join as join2, resolve as resolve3, relative as relative2, dirname as dirname2, basename } from "path";
-import chalk3 from "chalk";
+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(chalk3.green(`\u2713 ${msg}`));
+  console.log(chalk4.green(`\u2713 ${msg}`));
 }
 function fail(ctx, msg) {
-  console.log(chalk3.red(`\u2717 ${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 = join2(dir, entry);
+    const full = join3(dir, entry);
     const s = await stat(full);
     if (s.isDirectory()) dirs.push(entry);
   }
@@ -702,21 +1485,21 @@ async function discoverAllScenarios(mocksDir) {
   const scenarios = [];
   const providers = await subdirs(mocksDir);
   for (const provider of providers) {
-    const providerDir = join2(mocksDir, provider);
+    const providerDir = join3(mocksDir, provider);
     for (const scenario of await subdirs(providerDir)) {
       scenarios.push(`${provider}/${scenario}`);
     }
   }
   return scenarios;
 }
-function resolveScenarioDir(arg3) {
-  const abs = resolve3(arg3);
+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(chalk3.bold(`
+  console.log(chalk4.bold(`
 \u2500\u2500 ${label} \u2500\u2500`));
   let entries;
   try {
@@ -727,7 +1510,7 @@ async function validateScenario(ctx, scenarioDir, mocksDir) {
   }
   const hasMock = checkStructure(ctx, entries, label);
   if (!hasMock) return;
-  const mockPath = join2(scenarioDir, "mock.json");
+  const mockPath = join3(scenarioDir, "mock.json");
   let data;
   try {
     data = JSON.parse(await readFile(mockPath, "utf-8"));
@@ -743,37 +1526,37 @@ async function validateScenario(ctx, scenarioDir, mocksDir) {
 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));
+  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(chalk3.bold("\nValidating mock configs...\n"));
+  console.log(chalk4.bold("\nValidating mock configs...\n"));
   for (const target of targets) {
     await validateScenario(ctx, target, mocksDir);
   }
-  console.log(chalk3.bold("\n\u2500\u2500 summary \u2500\u2500"));
+  console.log(chalk4.bold("\n\u2500\u2500 summary \u2500\u2500"));
   if (ctx.failures === 0) {
-    console.log(chalk3.green("\u2713 All checks passed"));
+    console.log(chalk4.green("\u2713 All checks passed"));
   } else {
-    console.log(chalk3.red(`\u2717 ${ctx.failures} check(s) failed`));
+    console.log(chalk4.red(`\u2717 ${ctx.failures} check(s) failed`));
   }
   return ctx.failures === 0 ? 0 : 1;
 }
 
 // src/commands/mock/index.ts
-var startCommand = defineCommand({
+var startCommand = defineCommand4({
   name: "start",
   description: "Start mock API servers with reverse proxy",
-  args: z.object({
-    mocksRoot: arg(z.string().default("./mocks"), {
+  args: z4.object({
+    mocksRoot: arg4(z4.string().default("./mocks"), {
       description: "Path to mocks directory"
     }),
-    port: arg(z.coerce.number().default(3e3), {
+    port: arg4(z4.coerce.number().default(3e3), {
       alias: "p",
       description: "Reverse proxy port"
     }),
-    filter: arg(z.array(z.string()).default([]), {
+    filter: arg4(z4.array(z4.string()).default([]), {
       positional: true,
       description: "Filter by provider or provider/scenario"
     })
@@ -783,14 +1566,14 @@ var startCommand = defineCommand({
     process.exit(exitCode);
   }
 });
-var validateCommand = defineCommand({
+var validateCommand = defineCommand4({
   name: "validate",
   description: "Validate mock scenario configs",
-  args: z.object({
-    mocksRoot: arg(z.string().default("./mocks"), {
+  args: z4.object({
+    mocksRoot: arg4(z4.string().default("./mocks"), {
       description: "Path to mocks directory"
     }),
-    paths: arg(z.array(z.string()).default([]), {
+    paths: arg4(z4.array(z4.string()).default([]), {
       positional: true,
       description: "Specific scenario paths to validate"
     })
@@ -800,7 +1583,7 @@ var validateCommand = defineCommand({
     process.exit(exitCode);
   }
 });
-var mockCommand = defineCommand({
+var mockCommand = defineCommand4({
   name: "mock",
   description: "Mock API server management",
   subCommands: {
@@ -809,106 +1592,63 @@ var mockCommand = defineCommand({
   }
 });
 
-// src/cli.ts
-var cwd = process.cwd();
-var rootArgs = z2.object({
-  modulesRoot: arg2(z2.string().optional(), {
-    alias: "m",
-    description: "Path to modules directory"
+// 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"
+    })
   }),
-  appRoot: arg2(z2.string().optional(), {
-    alias: "a",
-    description: "Path to app-compose directory (apps/ or examples/)"
-  })
-});
-function requireRoot(args) {
-  const paths = { modulesRoot: args.modulesRoot, appRoot: args.appRoot };
-  if (!paths.modulesRoot && !paths.appRoot) {
-    console.error("At least one of --modules-root or --app-root is required.");
-    process.exit(2);
-  }
-  return paths;
-}
-var checkCommand = defineCommand2({
-  name: "check",
-  description: "Validate docs against schemas",
-  args: rootArgs,
-  run: async (args) => {
-    const paths = requireRoot(args);
-    const exitCode = await runCheck(paths, cwd);
+  run: (args) => {
+    const exitCode = runInit(cwd4, args.force);
     process.exit(exitCode);
   }
 });
-var syncCheckCommand = defineCommand2({
-  name: "sync-check",
-  description: "Validate source <-> doc correspondence",
-  args: rootArgs,
-  run: async (args) => {
-    const paths = requireRoot(args);
-    const result = await runSyncCheck(paths, cwd);
-    console.log(formatSyncCheckReport(result));
-    process.exit(result.exitCode);
-  }
-});
-var scaffoldCommand = defineCommand2({
-  name: "scaffold",
-  description: "Generate doc file from schema template",
-  args: rootArgs.extend({
-    type: arg2(z2.enum(ALL_TYPES), {
-      positional: true,
-      description: `Scaffold type (${ALL_TYPES.join(", ")})`
-    }),
-    parent: arg2(z2.string(), {
-      positional: true,
-      description: "Parent name (module or app name)"
-    }),
-    name: arg2(z2.string().optional(), {
-      positional: true,
-      description: "Item name (required for most types)"
+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: async (args) => {
-    const paths = requireRoot(args);
-    const root = isModuleType(args.type) ? paths.modulesRoot : paths.appRoot;
-    if (!root) {
-      console.error(
-        `--${isModuleType(args.type) ? "modules-root" : "app-root"} is required for scaffold type "${args.type}".`
-      );
-      process.exit(2);
-    }
-    const exitCode = await runScaffold(
-      args.type,
-      args.parent,
-      args.name,
-      root,
-      cwd
-    );
+  run: (args) => {
+    const exitCode = runLicenseCheck(args.config);
     process.exit(exitCode);
   }
 });
-var initCommand = defineCommand2({
-  name: "init",
-  description: "Set up consumer repo with framework skills",
-  args: z2.object({
-    force: arg2(z2.boolean().default(false), {
-      alias: "f",
-      description: "Overwrite existing skills"
-    })
-  }),
-  run: (args) => {
-    const exitCode = runInit(cwd, args.force);
+var licenseListCommand = defineCommand5({
+  name: "list",
+  description: "List available license groups",
+  run: () => {
+    const exitCode = runLicenseList();
     process.exit(exitCode);
   }
 });
-var main = defineCommand2({
+var licenseCommand = defineCommand5({
+  name: "license",
+  description: "License management",
+  subCommands: {
+    check: licenseCheckCommand,
+    list: licenseListCommand
+  }
+});
+var mainCommand = defineCommand5({
   name: "erp-kit",
-  description: "Documentation validation and scaffolding tool",
+  description: "ERP module framework CLI",
   subCommands: {
-    check: checkCommand,
-    "sync-check": syncCheckCommand,
-    scaffold: scaffoldCommand,
+    module: moduleCommand,
+    app: appCommand,
+    mock: mockCommand,
     init: initCommand,
-    mock: mockCommand
+    license: licenseCommand
   }
 });
-void runMain(main);
+
+// src/cli.ts
+void runMain(mainCommand);