@tailor-platform/erp-kit 0.2.2 → 0.3.0

package/src/{commands/scaffold.test.ts → generator/generate-code-boilerplate.test.ts}

@@ -2,88 +2,9 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { describe, it, expect, afterEach } from "vitest";
-import { resolveScaffoldPath, scaffoldModuleSrc, copyTemplateDir } from "./scaffold";
+import { copyTemplateDir, scaffoldModuleBoilerplate } from "./generate-code";
 
-describe("resolveScaffoldPath", () => {
-  // Module types
-  it("resolves module scaffold path", () => {
-    const result = resolveScaffoldPath("module", "inventory", undefined, "modules");
-    expect(result).toBe("modules/inventory/README.md");
-  });
-
-  it("resolves command scaffold path", () => {
-    const result = resolveScaffoldPath("command", "inventory", "CreateOrder", "modules");
-    expect(result).toBe("modules/inventory/docs/commands/CreateOrder.md");
-  });
-
-  it("resolves feature scaffold path", () => {
-    const result = resolveScaffoldPath("feature", "inventory", "stock-tracking", "modules");
-    expect(result).toBe("modules/inventory/docs/features/stock-tracking.md");
-  });
-
-  it("resolves model scaffold path", () => {
-    const result = resolveScaffoldPath("model", "inventory", "StockItem", "modules");
-    expect(result).toBe("modules/inventory/docs/models/StockItem.md");
-  });
-
-  // App-compose types
-  it("resolves app scaffold path", () => {
-    const result = resolveScaffoldPath("app", "my-app", undefined, "examples");
-    expect(result).toBe("examples/my-app/README.md");
-  });
-
-  it("resolves actors scaffold path", () => {
-    const result = resolveScaffoldPath("actors", "my-app", "admin", "examples");
-    expect(result).toBe("examples/my-app/docs/actors/admin.md");
-  });
-
-  it("resolves business-flow scaffold path", () => {
-    const result = resolveScaffoldPath("business-flow", "my-app", "onboarding", "examples");
-    expect(result).toBe("examples/my-app/docs/business-flow/onboarding/README.md");
-  });
-
-  it("resolves story scaffold path with flow/name format", () => {
-    const result = resolveScaffoldPath(
-      "story",
-      "my-app",
-      "onboarding/admin--create-user",
-      "examples",
-    );
-    expect(result).toBe(
-      "examples/my-app/docs/business-flow/onboarding/story/admin--create-user.md",
-    );
-  });
-
-  it("resolves screen scaffold path", () => {
-    const result = resolveScaffoldPath("screen", "my-app", "supplier-list", "examples");
-    expect(result).toBe("examples/my-app/docs/screen/supplier-list.md");
-  });
-
-  it("resolves resolver scaffold path", () => {
-    const result = resolveScaffoldPath("resolver", "my-app", "create-supplier", "examples");
-    expect(result).toBe("examples/my-app/docs/resolver/create-supplier.md");
-  });
-
-  it("resolves query scaffold path", () => {
-    const result = resolveScaffoldPath("query", "inventory", "ConvertQuantity", "modules");
-    expect(result).toBe("modules/inventory/docs/queries/ConvertQuantity.md");
-  });
-
-  // Validation
-  it("throws when name is required but missing", () => {
-    expect(() => resolveScaffoldPath("command", "inventory", undefined, "modules")).toThrow(
-      "Name is required",
-    );
-  });
-
-  it("throws when story name is not flow/name format", () => {
-    expect(() => resolveScaffoldPath("story", "my-app", "bad-name", "examples")).toThrow(
-      "Story name must be",
-    );
-  });
-});
-
-describe("scaffoldModuleSrc", () => {
+describe("scaffoldModuleBoilerplate", () => {
   let tmpDir: string;
 
   afterEach(() => {
@@ -97,19 +18,16 @@ describe("scaffoldModuleSrc", () => {
     const moduleDir = path.join(tmpDir, "test-module");
     fs.mkdirSync(moduleDir, { recursive: true });
 
-    scaffoldModuleSrc(moduleDir, "test-module");
+    scaffoldModuleBoilerplate(moduleDir, "test-module");
 
-    // Verify directories exist directly under module root (flat structure)
     for (const dir of ["db", "command", "executor", "generated", "lib", "query", "testing"]) {
       expect(fs.existsSync(path.join(moduleDir, dir))).toBe(true);
     }
 
-    // Verify .gitkeep in empty directories
     for (const dir of ["db", "command", "executor", "generated", "query"]) {
       expect(fs.existsSync(path.join(moduleDir, dir, ".gitkeep"))).toBe(true);
     }
 
-    // Verify starter files exist
     const expectedFiles = [
       "module.ts",
       "index.ts",
@@ -123,7 +41,6 @@ describe("scaffoldModuleSrc", () => {
       expect(fs.existsSync(path.join(moduleDir, file))).toBe(true);
     }
 
-    // Verify module name is used in content
     const permissions = fs.readFileSync(path.join(moduleDir, "permissions.ts"), "utf-8");
     expect(permissions).toContain('definePermissions("test-module"');
 
@@ -151,7 +68,6 @@ describe("copyTemplateDir", () => {
     const srcDir = path.join(tmpDir, "src");
     const destDir = path.join(tmpDir, "dest");
 
-    // Build a minimal fixture
     fs.mkdirSync(path.join(srcDir, "backend"), { recursive: true });
     fs.mkdirSync(path.join(srcDir, "frontend/src"), { recursive: true });
     fs.writeFileSync(
@@ -174,13 +90,11 @@ describe("copyTemplateDir", () => {
     const placeholderFiles = new Set(["package.json", "index.html"]);
     copyTemplateDir(srcDir, destDir, replacements, placeholderFiles);
 
-    // Files are copied
     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);
 
-    // Placeholder replacement
     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");
@@ -209,4 +123,20 @@ describe("copyTemplateDir", () => {
     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,6 +6,7 @@ import {
   generateQueryShell,
   generateQueryStub,
   generateQueryTestStub,
+  generateDbStub,
   moduleNameToPrefix,
 } from "./generate-code";
 import type { ParsedCommandDoc } from "./parse-command-doc";
@@ -189,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 = {

package/src/generator/generate-code.ts

@@ -1,5 +1,6 @@
 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 moduleNameToPrefix(moduleName: string): string {
@@ -141,6 +142,19 @@ 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");
@@ -154,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[] = [];
@@ -261,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

@@ -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",

package/templates/scaffold/app/backend/package.json

@@ -16,15 +16,15 @@
     "@tailor-platform/erp-kit": "workspace:*",
     "@tailor-platform/function-kysely-tailordb": "0.1.3",
     "@tailor-platform/sdk": "1.25.1",
-    "kysely": "0.28.10"
+    "kysely": "0.28.11"
   },
   "devDependencies": {
     "@eslint/js": "9.39.4",
-    "@tailor-platform/function-types": "0.8.1",
-    "@types/node": "24.10.9",
+    "@tailor-platform/function-types": "0.8.2",
+    "@types/node": "24.12.0",
     "eslint": "9.39.4",
     "eslint-import-resolver-typescript": "4.4.4",
-    "eslint-plugin-import-x": "4.16.1",
+    "eslint-plugin-import-x": "4.16.2",
     "typescript": "5.9.3",
     "typescript-eslint": "8.57.0"
   }

package/templates/scaffold/app/frontend/package.json

@@ -19,32 +19,32 @@
     "class-variance-authority": "0.7.1",
     "clsx": "2.1.1",
     "gql.tada": "1.9.0",
-    "lucide-react": "0.563.0",
+    "lucide-react": "0.577.0",
     "react": "19.2.4",
     "react-dom": "19.2.4",
-    "react-hook-form": "7.71.1",
-    "tailwind-merge": "3.4.0",
+    "react-hook-form": "7.71.2",
+    "tailwind-merge": "3.5.0",
     "urql": "5.0.1",
     "zod": "4.3.6"
   },
   "devDependencies": {
     "@eslint/js": "9.39.4",
     "@tailor-platform/app-shell-vite-plugin": "0.1.0",
-    "@tailwindcss/vite": "4.1.18",
-    "@types/node": "25.1.0",
-    "@types/react": "19.2.10",
+    "@tailwindcss/vite": "4.2.1",
+    "@types/node": "25.5.0",
+    "@types/react": "19.2.14",
     "@types/react-dom": "19.2.3",
-    "@vitejs/plugin-react": "5.1.2",
+    "@vitejs/plugin-react": "5.2.0",
     "babel-plugin-react-compiler": "1.0.0",
     "eslint": "9.39.4",
     "eslint-import-resolver-typescript": "4.4.4",
-    "eslint-plugin-import-x": "4.16.1",
+    "eslint-plugin-import-x": "4.16.2",
     "eslint-plugin-react-dom": "2.13.0",
     "eslint-plugin-react-hooks": "7.0.1",
     "eslint-plugin-react-x": "2.13.0",
-    "globals": "17.2.0",
+    "globals": "17.4.0",
     "shadcn": "^3.8.4",
-    "tailwindcss": "4.1.18",
+    "tailwindcss": "4.2.1",
     "tw-animate-css": "1.4.0",
     "typescript": "5.9.3",
     "typescript-eslint": "8.57.0",

package/templates/workflows/erp-kit-check.yml

@@ -28,10 +28,10 @@ jobs:
       - run: pnpm install --frozen-lockfile
 
       - name: Validate app documentation
-        run: npx @tailor-platform/erp-kit app check --root .
+        run: npx @tailor-platform/erp-kit app check --path .
 
       - name: Validate source-doc correspondence
-        run: npx @tailor-platform/erp-kit app sync-check --root .
+        run: npx @tailor-platform/erp-kit app sync-check --path .
 
       - name: Check licenses
         run: npx @tailor-platform/erp-kit license check --config license.config.json

package/src/commands/scaffold.ts

@@ -1,176 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-import { runMdschema } from "../mdschema";
-import { ALL_SCHEMAS } from "../schemas";
-import { PACKAGE_ROOT, readErpKitVersion } from "../util";
-
-export const MODULE_TYPES = ["module", "feature", "command", "model", "query"] as const;
-export const APP_TYPES = ["app", "actors", "business-flow", "story", "screen", "resolver"] as const;
-export const ALL_TYPES = [...MODULE_TYPES, ...APP_TYPES] as const;
-
-export type ScaffoldType = (typeof ALL_TYPES)[number];
-
-const MODULE_DIR_MAP: Record<string, string> = {
-  feature: "docs/features",
-  command: "docs/commands",
-  model: "docs/models",
-  query: "docs/queries",
-};
-
-const APP_DIR_MAP: Record<string, string> = {
-  actors: "docs/actors",
-  "business-flow": "docs/business-flow",
-  screen: "docs/screen",
-  resolver: "docs/resolver",
-};
-
-export function isModuleType(type: string): boolean {
-  return (MODULE_TYPES as readonly string[]).includes(type);
-}
-
-export function resolveScaffoldPath(
-  type: ScaffoldType,
-  parentName: string,
-  name: string | undefined,
-  root: string,
-): string {
-  // Types that map to README.md (no name needed)
-  if (type === "module" || type === "app") {
-    return path.join(root, parentName, "README.md");
-  }
-
-  if (!name) {
-    throw new Error(`Name is required for scaffold type "${type}"`);
-  }
-
-  // business-flow produces a README inside a named directory
-  if (type === "business-flow") {
-    return path.join(root, parentName, "docs/business-flow", name, "README.md");
-  }
-
-  // story accepts "flow/story-name" to place under the correct flow directory
-  if (type === "story") {
-    const parts = name.split("/");
-    if (parts.length !== 2) {
-      throw new Error(
-        `Story name must be "<flow>/<story>" (e.g., "onboarding/admin--create-user")`,
-      );
-    }
-    return path.join(root, parentName, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
-  }
-
-  // Module sub-types
-  if (MODULE_DIR_MAP[type]) {
-    return path.join(root, parentName, MODULE_DIR_MAP[type], `${name}.md`);
-  }
-
-  // App sub-types
-  if (APP_DIR_MAP[type]) {
-    return path.join(root, parentName, APP_DIR_MAP[type], `${name}.md`);
-  }
-
-  throw new Error(`Unknown scaffold type: ${type}`);
-}
-
-export async function runScaffold(
-  type: ScaffoldType,
-  parentName: string,
-  name: string | undefined,
-  root: string,
-  cwd: string,
-): Promise<number> {
-  const outputPath = resolveScaffoldPath(type, parentName, name, root);
-  const absoluteOutput = path.resolve(cwd, outputPath);
-
-  if (fs.existsSync(absoluteOutput)) {
-    console.error(`File already exists: ${outputPath}`);
-    return 1;
-  }
-
-  const schemaPath = ALL_SCHEMAS[type];
-  if (!schemaPath) {
-    console.error(`No schema found for type: ${type}`);
-    return 2;
-  }
-
-  try {
-    fs.mkdirSync(path.dirname(absoluteOutput), { recursive: true });
-  } catch (err) {
-    console.error(
-      `Failed to create directory: ${err instanceof Error ? err.message : String(err)}`,
-    );
-    return 1;
-  }
-
-  const { exitCode, stdout, stderr } = await runMdschema(
-    ["generate", "--schema", schemaPath, "--output", absoluteOutput],
-    cwd,
-  );
-
-  if (stdout.trim()) console.log(stdout);
-  if (stderr.trim()) console.error(stderr);
-
-  if (exitCode !== 0) return exitCode;
-
-  if (type === "module") {
-    scaffoldModuleSrc(path.dirname(absoluteOutput), parentName);
-  }
-
-  if (type === "app") {
-    scaffoldAppSrc(path.dirname(absoluteOutput), parentName);
-  }
-
-  return exitCode;
-}
-
-// npm renames .gitignore → .npmignore during pack (npm/cli#5756).
-// prepack copies .gitignore → __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 {
-      fs.mkdirSync(path.dirname(destPath), { recursive: true });
-      if (placeholderFiles.has(entry.name)) {
-        // Replace placeholders (e.g. "template-module" → actual 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 scaffoldModuleSrc(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 scaffoldAppSrc(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);
-}