@tailor-platform/erp-kit 0.2.1 → 0.3.0

package/src/generator/generate-code-boilerplate.test.ts

@@ -0,0 +1,142 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, it, expect, afterEach } from "vitest";
+import { copyTemplateDir, scaffoldModuleBoilerplate } from "./generate-code";
+
+describe("scaffoldModuleBoilerplate", () => {
+  let tmpDir: string;
+
+  afterEach(() => {
+    if (tmpDir) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("creates expected directories and files", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "scaffold-test-"));
+    const moduleDir = path.join(tmpDir, "test-module");
+    fs.mkdirSync(moduleDir, { recursive: true });
+
+    scaffoldModuleBoilerplate(moduleDir, "test-module");
+
+    for (const dir of ["db", "command", "executor", "generated", "lib", "query", "testing"]) {
+      expect(fs.existsSync(path.join(moduleDir, dir))).toBe(true);
+    }
+
+    for (const dir of ["db", "command", "executor", "generated", "query"]) {
+      expect(fs.existsSync(path.join(moduleDir, dir, ".gitkeep"))).toBe(true);
+    }
+
+    const expectedFiles = [
+      "module.ts",
+      "index.ts",
+      "permissions.ts",
+      "tailor.config.ts",
+      "lib/errors.ts",
+      "lib/types.ts",
+      "testing/fixtures.ts",
+    ];
+    for (const file of expectedFiles) {
+      expect(fs.existsSync(path.join(moduleDir, file))).toBe(true);
+    }
+
+    const permissions = fs.readFileSync(path.join(moduleDir, "permissions.ts"), "utf-8");
+    expect(permissions).toContain('definePermissions("test-module"');
+
+    const config = fs.readFileSync(path.join(moduleDir, "tailor.config.ts"), "utf-8");
+    expect(config).toContain('name: "test-module"');
+
+    const moduleFile = fs.readFileSync(path.join(moduleDir, "module.ts"), "utf-8");
+    expect(moduleFile).toContain("defineModule");
+    expect(moduleFile).toContain("commands");
+    expect(moduleFile).toContain("queries");
+  });
+});
+
+describe("copyTemplateDir", () => {
+  let tmpDir: string;
+
+  afterEach(() => {
+    if (tmpDir) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("copies files recursively with placeholder replacement", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "copy-template-test-"));
+    const srcDir = path.join(tmpDir, "src");
+    const destDir = path.join(tmpDir, "dest");
+
+    fs.mkdirSync(path.join(srcDir, "backend"), { recursive: true });
+    fs.mkdirSync(path.join(srcDir, "frontend/src"), { recursive: true });
+    fs.writeFileSync(
+      path.join(srcDir, "backend/package.json"),
+      '{ "name": "template-app-backend", "dependencies": { "@tailor-platform/erp-kit": "workspace:*" } }\n',
+    );
+    fs.writeFileSync(
+      path.join(srcDir, "frontend/package.json"),
+      '{ "name": "template-app-frontend" }\n',
+    );
+    fs.writeFileSync(path.join(srcDir, "frontend/index.html"), "<title>template-app</title>\n");
+    fs.writeFileSync(path.join(srcDir, "frontend/src/main.tsx"), "// app\n");
+
+    const replacements = {
+      "template-app-frontend": "my-app-frontend",
+      "template-app-backend": "my-app",
+      "template-app": "my-app",
+      '"workspace:*"': '"1.0.0"',
+    };
+    const placeholderFiles = new Set(["package.json", "index.html"]);
+    copyTemplateDir(srcDir, destDir, replacements, placeholderFiles);
+
+    expect(fs.existsSync(path.join(destDir, "backend/package.json"))).toBe(true);
+    expect(fs.existsSync(path.join(destDir, "frontend/package.json"))).toBe(true);
+    expect(fs.existsSync(path.join(destDir, "frontend/index.html"))).toBe(true);
+    expect(fs.existsSync(path.join(destDir, "frontend/src/main.tsx"))).toBe(true);
+
+    const backendPkg = fs.readFileSync(path.join(destDir, "backend/package.json"), "utf-8");
+    expect(backendPkg).toContain('"name": "my-app"');
+    expect(backendPkg).not.toContain("template-app-backend");
+    expect(backendPkg).toContain('"1.0.0"');
+    expect(backendPkg).not.toContain("workspace:*");
+
+    const frontendPkg = fs.readFileSync(path.join(destDir, "frontend/package.json"), "utf-8");
+    expect(frontendPkg).toContain('"name": "my-app-frontend"');
+    expect(frontendPkg).not.toContain("template-app-frontend");
+
+    const indexHtml = fs.readFileSync(path.join(destDir, "frontend/index.html"), "utf-8");
+    expect(indexHtml).toContain("<title>my-app</title>");
+    expect(indexHtml).not.toContain("template-app");
+  });
+
+  it("renames __dot__gitignore to .gitignore", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "copy-template-test-"));
+    const srcDir = path.join(tmpDir, "src");
+    const destDir = path.join(tmpDir, "dest");
+
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "__dot__gitignore"), "node_modules\n");
+
+    copyTemplateDir(srcDir, destDir, {}, new Set());
+
+    expect(fs.existsSync(path.join(destDir, ".gitignore"))).toBe(true);
+    expect(fs.existsSync(path.join(destDir, "__dot__gitignore"))).toBe(false);
+  });
+
+  it("does not overwrite existing files", () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "copy-template-test-"));
+    const srcDir = path.join(tmpDir, "src");
+    const destDir = path.join(tmpDir, "dest");
+
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "file.txt"), "template content");
+    fs.writeFileSync(path.join(destDir, "file.txt"), "existing content");
+
+    copyTemplateDir(srcDir, destDir, {}, new Set());
+
+    const content = fs.readFileSync(path.join(destDir, "file.txt"), "utf-8");
+    expect(content).toBe("existing content");
+  });
+});

package/src/generator/generate-code.test.ts

@@ -6,11 +6,22 @@ import {
   generateQueryShell,
   generateQueryStub,
   generateQueryTestStub,
+  generateDbStub,
+  moduleNameToPrefix,
 } from "./generate-code";
 import type { ParsedCommandDoc } from "./parse-command-doc";
 
+describe("moduleNameToPrefix", () => {
+  it("converts module name to UPPER_SNAKE_CASE prefix", () => {
+    expect(moduleNameToPrefix("item-management")).toBe("ITEM_MANAGEMENT");
+    expect(moduleNameToPrefix("primitives")).toBe("PRIMITIVES");
+    expect(moduleNameToPrefix("user-management")).toBe("USER_MANAGEMENT");
+    expect(moduleNameToPrefix("product-management")).toBe("PRODUCT_MANAGEMENT");
+  });
+});
+
 describe("generateErrors", () => {
-  it("generates error classes from parsed command docs", () => {
+  it("generates error classes with module-prefixed codes", () => {
     const docs: ParsedCommandDoc[] = [
       {
         commandName: "createItem",
@@ -30,13 +41,14 @@ describe("generateErrors", () => {
       },
     ];
 
-    const result = generateErrors(docs);
+    const result = generateErrors("item-management", docs);
 
     expect(result).toContain("// @generated — do not edit");
-    expect(result).toContain('import { createDomainError } from "../../shared/internal";');
+    expect(result).toContain('import { createDomainError } from "../../../shared";');
     expect(result).toContain("export const DuplicateSkuError = createDomainError(");
-    expect(result).toContain('"DuplicateSkuError", "DUPLICATE_SKU"');
+    expect(result).toContain('"DuplicateSkuError", "ITEM_MANAGEMENT_DUPLICATE_SKU"');
     expect(result).toContain("export const UnitNotFoundError = createDomainError(");
+    expect(result).toContain('"UnitNotFoundError", "ITEM_MANAGEMENT_UNIT_NOT_FOUND"');
     expect(result).toContain("export const ItemNotFoundError = createDomainError(");
     expect(result).toContain("export const InvalidStateTransitionError = createDomainError(");
   });
@@ -55,7 +67,7 @@ describe("generateErrors", () => {
       },
     ];
 
-    const result = generateErrors(docs);
+    const result = generateErrors("item-management", docs);
 
     const matches = result.match(/ItemNotFoundError/g);
     // Class name appears exactly twice: export declaration + first arg to createDomainError
@@ -67,7 +79,7 @@ describe("generateErrors", () => {
       { commandName: "noop", errors: [], externalDependencies: [] },
     ];
 
-    const result = generateErrors(docs);
+    const result = generateErrors("item-management", docs);
 
     expect(result).toBe("");
   });
@@ -80,7 +92,7 @@ describe("generatePermissions", () => {
     const result = generatePermissions("item-management", commandNames);
 
     expect(result).toContain("// @generated — do not edit");
-    expect(result).toContain('import { definePermissions } from "../../shared/internal";');
+    expect(result).toContain('import { definePermissions } from "../../../shared";');
     expect(result).toContain('"item-management"');
     expect(result).toContain('"createItem"');
     expect(result).toContain('"updateItem"');
@@ -116,7 +128,7 @@ describe("generateCommandShell", () => {
     const result = generateCommandShell(doc);
 
     expect(result).toContain("// @generated — do not edit");
-    expect(result).toContain('import { defineCommand } from "../../shared/internal";');
+    expect(result).toContain('import { defineCommand } from "../../../shared";');
     expect(result).toContain('import { permissions } from "../lib/permissions.generated";');
     expect(result).toContain('import { run } from "./activateItem";');
     expect(result).toContain(
@@ -133,7 +145,7 @@ describe("generateCommandShell", () => {
 
     const result = generateCommandShell(doc);
 
-    expect(result).toContain('import { defineCommand } from "../../shared/internal";');
+    expect(result).toContain('import { defineCommand } from "../../../shared";');
     expect(result).toContain('import { run } from "./createItem";');
     expect(result).toContain(
       "export const createItem = defineCommand(permissions.createItem, run);",
@@ -152,7 +164,7 @@ describe("generateQueryShell", () => {
     const result = generateQueryShell(doc);
 
     expect(result).toContain("// @generated — do not edit");
-    expect(result).toContain('import { defineQuery } from "../../shared/internal";');
+    expect(result).toContain('import { defineQuery } from "../../../shared";');
     expect(result).toContain('import { run } from "./getTaxonomyNode";');
     expect(result).toContain("export const getTaxonomyNode = defineQuery(run);");
   });
@@ -168,7 +180,7 @@ describe("generateQueryStub", () => {
 
     const result = generateQueryStub(doc);
 
-    expect(result).toContain('import type { ReadonlyDB } from "../../shared/internal";');
+    expect(result).toContain('import type { ReadonlyDB } from "../../../shared";');
     expect(result).toContain('import type { DB } from "../generated/kysely-tailordb";');
     expect(result).toContain("export interface GetTaxonomyNodeInput {");
     expect(result).toContain(
@@ -178,6 +190,29 @@ describe("generateQueryStub", () => {
   });
 });
 
+describe("generateDbStub", () => {
+  it("generates an empty db type definition with TODO", () => {
+    const result = generateDbStub("item");
+
+    expect(result).toContain(
+      "import { db, unsafeAllowAllGqlPermission, unsafeAllowAllTypePermission }",
+    );
+    expect(result).toContain("export const item = db");
+    expect(result).toContain('.type("Item"');
+    expect(result).toContain("// TODO: define fields");
+    expect(result).toContain("...db.fields.timestamps()");
+    expect(result).toContain(".permission(unsafeAllowAllTypePermission)");
+    expect(result).toContain(".gqlPermission(unsafeAllowAllGqlPermission)");
+  });
+
+  it("handles camelCase model names", () => {
+    const result = generateDbStub("taxonomyNode");
+
+    expect(result).toContain("export const taxonomyNode = db");
+    expect(result).toContain('.type("TaxonomyNode"');
+  });
+});
+
 describe("generateQueryTestStub", () => {
   it("generates a test stub with createMockDb and run import", () => {
     const doc: ParsedCommandDoc = {
@@ -189,7 +224,7 @@ describe("generateQueryTestStub", () => {
     const result = generateQueryTestStub(doc);
 
     expect(result).toContain('import { describe, expect, it } from "vitest";');
-    expect(result).toContain('import { createMockDb } from "../../testing/index";');
+    expect(result).toContain('import { createMockDb } from "../../../testing/index";');
     expect(result).toContain('import type { DB } from "../generated/kysely-tailordb";');
     expect(result).toContain('import { run, type GetTaxonomyNodeInput } from "./getTaxonomyNode";');
     expect(result).toContain('describe("getTaxonomyNode"');

package/src/generator/generate-code.ts

@@ -1,10 +1,16 @@
 import fs from "node:fs";
 import path from "node:path";
+import { PACKAGE_ROOT, readErpKitVersion } from "../util";
 import { parseCommandDoc, errorCodeToClassName, type ParsedCommandDoc } from "./parse-command-doc";
 
-export function generateErrors(docs: ParsedCommandDoc[]): string {
+export function moduleNameToPrefix(moduleName: string): string {
+  return moduleName.toUpperCase().replace(/-/g, "_");
+}
+
+export function generateErrors(moduleName: string, docs: ParsedCommandDoc[]): string {
   const seen = new Set<string>();
   const lines: string[] = [];
+  const prefix = moduleNameToPrefix(moduleName);
 
   for (const doc of docs) {
     for (const error of doc.errors) {
@@ -12,8 +18,9 @@ export function generateErrors(docs: ParsedCommandDoc[]): string {
       seen.add(error.code);
 
       const className = errorCodeToClassName(error.code);
+      const prefixedCode = `${prefix}_${error.code}`;
       lines.push(`export const ${className} = createDomainError(`);
-      lines.push(`  "${className}", "${error.code}",`);
+      lines.push(`  "${className}", "${prefixedCode}",`);
       const escapedDesc = error.description.replace(/`/g, "'");
       lines.push(`  (identifier: string) => \`${escapedDesc}: \${identifier}\`,`);
       lines.push(`);`);
@@ -24,7 +31,7 @@ export function generateErrors(docs: ParsedCommandDoc[]): string {
   if (lines.length === 0) return "";
 
   return `// @generated — do not edit
-import { createDomainError } from "../../shared/internal";
+import { createDomainError } from "../../../shared";
 
 ${lines.join("\n")}`;
 }
@@ -33,14 +40,14 @@ export function generateCommandStub(doc: ParsedCommandDoc): string {
   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";
+  return `import { ok, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
 
 export interface ${inputType} {
   // TODO: define input fields
 }
 
-export async function run(db: DB, input: ${inputType}, ctx: CommandContext) {
+export async function run(db: Transaction, input: ${inputType}, ctx: CommandContext) {
   // TODO: implement
   return ok({});
 }
@@ -51,9 +58,9 @@ export function generateTestStub(doc: ParsedCommandDoc): string {
   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 { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
 import { run, ${pascal}Input } from "./${doc.commandName}";
 
 describe("${doc.commandName} - test scenario", () => {
@@ -63,7 +70,7 @@ describe("${doc.commandName} - test scenario", () => {
   };
 
   it("should be implemented", async () => {
-    const { db } = createMockDb<DB>();
+    const { db } = createMockDb<Transaction>();
     const result = await run(db, {} as ${pascal}Input, ctx);
     expect(result.ok).toBe(true);
   });
@@ -74,7 +81,7 @@ describe("${doc.commandName} - test scenario", () => {
 export function generateCommandShell(doc: ParsedCommandDoc): string {
   const lines: string[] = [
     `// @generated — do not edit`,
-    `import { defineCommand } from "../../shared/internal";`,
+    `import { defineCommand } from "../../../shared";`,
     `import { permissions } from "../lib/permissions.generated";`,
     `import { run } from "./${doc.commandName}";`,
     ``,
@@ -88,7 +95,7 @@ export function generateCommandShell(doc: ParsedCommandDoc): string {
 export function generateQueryShell(doc: ParsedCommandDoc): string {
   const lines: string[] = [
     `// @generated — do not edit`,
-    `import { defineQuery } from "../../shared/internal";`,
+    `import { defineQuery } from "../../../shared";`,
     `import { run } from "./${doc.commandName}";`,
     ``,
     `export const ${doc.commandName} = defineQuery(run);`,
@@ -102,7 +109,7 @@ export function generateQueryStub(doc: ParsedCommandDoc): string {
   const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
   const inputType = `${pascal}Input`;
 
-  return `import type { ReadonlyDB } from "../../shared/internal";
+  return `import type { ReadonlyDB } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export interface ${inputType} {
@@ -121,7 +128,7 @@ export function generateQueryTestStub(doc: ParsedCommandDoc): string {
   const inputType = `${pascal}Input`;
 
   return `import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import type { DB } from "../generated/kysely-tailordb";
 import { run, type ${inputType} } from "./${doc.commandName}";
 
@@ -135,12 +142,25 @@ describe("${doc.commandName}", () => {
 `;
 }
 
+export function generateDbStub(modelName: string): string {
+  return `import { db, unsafeAllowAllGqlPermission, unsafeAllowAllTypePermission } from "@tailor-platform/sdk";
+
+export const ${modelName} = db
+  .type("${modelName.charAt(0).toUpperCase() + modelName.slice(1)}", {
+    // TODO: define fields
+    ...db.fields.timestamps(),
+  })
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);
+`;
+}
+
 export function generatePermissions(moduleName: string, commandNames: string[]): string {
   const sorted = [...commandNames].sort();
   const entries = sorted.map((name) => `  "${name}",`).join("\n");
 
   return `// @generated — do not edit
-import { definePermissions } from "../../shared/internal";
+import { definePermissions } from "../../../shared";
 
 export const { permissions, own, all } = definePermissions("${moduleName}", [
 ${entries}
@@ -148,20 +168,83 @@ ${entries}
 `;
 }
 
+// npm renames .gitignore during pack (npm/cli#5756).
+// prepack copies .gitignore to __dot__gitignore to preserve it.
+export function copyTemplateDir(
+  srcDir: string,
+  destDir: string,
+  replacements: Record<string, string>,
+  placeholderFiles: Set<string>,
+): void {
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destName = entry.name === "__dot__gitignore" ? ".gitignore" : entry.name;
+    const destPath = path.join(destDir, destName);
+
+    if (entry.isDirectory()) {
+      fs.mkdirSync(destPath, { recursive: true });
+      copyTemplateDir(srcPath, destPath, replacements, placeholderFiles);
+    } else {
+      if (fs.existsSync(destPath)) continue;
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      if (placeholderFiles.has(entry.name)) {
+        let content = fs.readFileSync(srcPath, "utf-8");
+        for (const [from, to] of Object.entries(replacements)) {
+          content = content.replaceAll(from, to);
+        }
+        fs.writeFileSync(destPath, content);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+}
+
+export function scaffoldModuleBoilerplate(moduleDir: string, moduleName: string): void {
+  const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "module");
+  const replacements = { "template-module": moduleName };
+  const placeholderFiles = new Set(["permissions.ts", "tailor.config.ts"]);
+  copyTemplateDir(templateDir, moduleDir, replacements, placeholderFiles);
+}
+
+export function scaffoldAppBoilerplate(appDir: string, appName: string): void {
+  const templateDir = path.join(PACKAGE_ROOT, "templates", "scaffold", "app");
+  const erpKitVersion = readErpKitVersion();
+  const replacements = {
+    "template-app-frontend": `${appName}-frontend`,
+    "template-app-backend": appName,
+    "template-app": appName,
+    '"workspace:*"': `"${erpKitVersion}"`,
+  };
+  const placeholderFiles = new Set(["package.json", "tailor.config.ts", "index.html"]);
+  copyTemplateDir(templateDir, appDir, replacements, placeholderFiles);
+}
+
+export function runGenerateAppCode(appPath: string): number {
+  const appName = path.basename(appPath);
+  scaffoldAppBoilerplate(appPath, appName);
+  console.log(`Generated boilerplate for ${appName}`);
+  return 0;
+}
+
 export function runGenerateCode(modulePath: string, moduleName: string): number {
+  scaffoldModuleBoilerplate(modulePath, moduleName);
+
   const docsDir = path.join(modulePath, "docs", "commands");
   const libDir = path.join(modulePath, "lib");
   const commandDir = path.join(modulePath, "command");
 
   if (!fs.existsSync(docsDir)) {
-    console.error(`No docs/commands/ directory found at ${docsDir}`);
-    return 1;
+    console.log(`No docs/commands/ directory found — skipping code generation`);
+    console.log(`Generated boilerplate for ${moduleName}`);
+    return 0;
   }
 
   const mdFiles = fs.readdirSync(docsDir).filter((f) => f.endsWith(".md"));
   if (mdFiles.length === 0) {
-    console.error(`No command docs found in ${docsDir}`);
-    return 1;
+    console.log(`No command docs found — skipping code generation`);
+    console.log(`Generated boilerplate for ${moduleName}`);
+    return 0;
   }
 
   const parsedDocs: ParsedCommandDoc[] = [];
@@ -186,7 +269,7 @@ export function runGenerateCode(modulePath: string, moduleName: string): number
 
   let generated = 0;
 
-  const errorsContent = generateErrors(allDocsForErrors);
+  const errorsContent = generateErrors(moduleName, allDocsForErrors);
   if (errorsContent) {
     fs.mkdirSync(libDir, { recursive: true });
     const errorsFile = path.join(libDir, "errors.generated.ts");
@@ -255,6 +338,26 @@ export function runGenerateCode(modulePath: string, moduleName: string): number
     }
   }
 
+  // Generate db stubs from docs/models/*.md
+  const modelDocsDir = path.join(modulePath, "docs", "models");
+  if (fs.existsSync(modelDocsDir)) {
+    const modelFiles = fs.readdirSync(modelDocsDir).filter((f) => f.endsWith(".md"));
+    if (modelFiles.length > 0) {
+      const dbDir = path.join(modulePath, "db");
+      fs.mkdirSync(dbDir, { recursive: true });
+
+      for (const file of modelFiles) {
+        const modelName = path.basename(file, ".md");
+        const camelName = modelName.charAt(0).toLowerCase() + modelName.slice(1);
+        const dbFile = path.join(dbDir, `${camelName}.ts`);
+        if (!fs.existsSync(dbFile)) {
+          fs.writeFileSync(dbFile, generateDbStub(camelName));
+          console.log(`  scaffolded ${path.relative(modulePath, dbFile)}`);
+        }
+      }
+    }
+  }
+
   console.log(`Generated ${generated} file(s) for ${moduleName}`);
   return 0;
 }

package/src/integration.test.ts

@@ -5,7 +5,7 @@ import path from "node:path";
 import { describe, it, expect } from "vitest";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const CLI_PATH = path.resolve(__dirname, "..", "dist", "cli.js");
+const CLI_PATH = path.resolve(__dirname, "..", "dist", "cli.mjs");
 const REPO_ROOT = path.resolve(__dirname, "..", "..", "..");
 
 const skipReason = fs.existsSync(CLI_PATH) ? undefined : "Run `pnpm build` first";
@@ -15,7 +15,7 @@ describe.skipIf(skipReason)("integration", () => {
     try {
       const result = execFileSync(
         "node",
-        [CLI_PATH, "module", "check", "--root", "packages/erp-kit/src/modules"],
+        [CLI_PATH, "module", "check", "--path", "packages/erp-kit/src/modules"],
         {
           cwd: REPO_ROOT,
           encoding: "utf-8",
@@ -35,7 +35,7 @@ describe.skipIf(skipReason)("integration", () => {
     try {
       const result = execFileSync(
         "node",
-        [CLI_PATH, "module", "sync-check", "--root", "packages/erp-kit/src/modules"],
+        [CLI_PATH, "module", "sync-check", "--path", "packages/erp-kit/src/modules"],
         {
           cwd: REPO_ROOT,
           encoding: "utf-8",