@tailor-platform/erp-kit 0.1.2 → 0.2.1

package/src/commands/index.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { defineCommand, arg } from "politty";
+import { runInit } from "./init";
+import { runLicenseCheck, runLicenseList } from "./license";
+import { moduleCommand } from "./module/index";
+import { appCommand } from "./app/index";
+import { mockCommand } from "./mock/index";
+
+export { moduleCommand } from "./module/index";
+export { appCommand } from "./app/index";
+export { mockCommand } from "./mock/index";
+
+const cwd = process.cwd();
+
+export const initCommand = defineCommand({
+  name: "init",
+  description: "Set up consumer repo with framework skills",
+  args: z.object({
+    force: arg(z.boolean().default(false), {
+      alias: "f",
+      description: "Overwrite existing skills",
+    }),
+  }),
+  run: (args) => {
+    const exitCode = runInit(cwd, args.force);
+    process.exit(exitCode);
+  },
+});
+
+const licenseCheckCommand = defineCommand({
+  name: "check",
+  description: "Check dependency licenses against allowlist",
+  args: z.object({
+    config: arg(z.string(), {
+      alias: "c",
+      description: "Path to license config JSON file",
+    }),
+  }),
+  run: (args) => {
+    const exitCode = runLicenseCheck(args.config);
+    process.exit(exitCode);
+  },
+});
+
+const licenseListCommand = defineCommand({
+  name: "list",
+  description: "List available license groups",
+  run: () => {
+    const exitCode = runLicenseList();
+    process.exit(exitCode);
+  },
+});
+
+const licenseCommand = defineCommand({
+  name: "license",
+  description: "License management",
+  subCommands: {
+    check: licenseCheckCommand,
+    list: licenseListCommand,
+  },
+});
+
+export const mainCommand = defineCommand({
+  name: "erp-kit",
+  description: "ERP module framework CLI",
+  subCommands: {
+    module: moduleCommand,
+    app: appCommand,
+    mock: mockCommand,
+    init: initCommand,
+    license: licenseCommand,
+  },
+});

package/src/commands/init.test.ts

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { runInit } from "./init.js";
+import { runInit } from "./init";
 
 describe("runInit", () => {
   let tmpDir: string;
@@ -17,7 +17,7 @@ describe("runInit", () => {
 
   it("copies framework skills to .agents/skills/", () => {
     runInit(tmpDir, false);
-    const skillPath = path.join(tmpDir, ".agents", "skills", "1-module-docs", "SKILL.md");
+    const skillPath = path.join(tmpDir, ".agents", "skills", "erp-kit-module-1-docs", "SKILL.md");
     expect(fs.existsSync(skillPath)).toBe(true);
   });
 
@@ -27,7 +27,7 @@ describe("runInit", () => {
       tmpDir,
       ".agents",
       "skills",
-      "4-module-tdd-implementation",
+      "erp-kit-module-4-tdd",
       "references",
       "models.md",
     );
@@ -47,7 +47,7 @@ describe("runInit", () => {
   });
 
   it("does not overwrite existing framework skills", () => {
-    const skillDir = path.join(tmpDir, ".agents", "skills", "1-module-docs");
+    const skillDir = path.join(tmpDir, ".agents", "skills", "erp-kit-module-1-docs");
     fs.mkdirSync(skillDir, { recursive: true });
     fs.writeFileSync(path.join(skillDir, "SKILL.md"), "# Customized");
     runInit(tmpDir, false);
@@ -56,7 +56,7 @@ describe("runInit", () => {
   });
 
   it("overwrites existing framework skills with --force", () => {
-    const skillDir = path.join(tmpDir, ".agents", "skills", "1-module-docs");
+    const skillDir = path.join(tmpDir, ".agents", "skills", "erp-kit-module-1-docs");
     fs.mkdirSync(skillDir, { recursive: true });
     fs.writeFileSync(path.join(skillDir, "SKILL.md"), "# Customized");
     runInit(tmpDir, true);
@@ -78,6 +78,23 @@ describe("runInit", () => {
     expect(fs.lstatSync(claudeSkills).isSymbolicLink()).toBe(false);
   });
 
+  it("removes stale erp-kit-* skills with --force", () => {
+    const staleDir = path.join(tmpDir, ".agents", "skills", "erp-kit-old-skill");
+    fs.mkdirSync(staleDir, { recursive: true });
+    fs.writeFileSync(path.join(staleDir, "SKILL.md"), "# Stale");
+    runInit(tmpDir, true);
+    expect(fs.existsSync(staleDir)).toBe(false);
+  });
+
+  it("preserves non-erp-kit skills with --force", () => {
+    const customDir = path.join(tmpDir, ".agents", "skills", "my-custom-skill");
+    fs.mkdirSync(customDir, { recursive: true });
+    fs.writeFileSync(path.join(customDir, "SKILL.md"), "# Custom");
+    runInit(tmpDir, true);
+    expect(fs.existsSync(path.join(customDir, "SKILL.md"))).toBe(true);
+    expect(fs.readFileSync(path.join(customDir, "SKILL.md"), "utf-8")).toBe("# Custom");
+  });
+
   it("relinks symlink with --force when target differs", () => {
     const claudeSkills = path.join(tmpDir, ".claude", "skills");
     fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });

package/src/commands/init.ts

@@ -1,24 +1,17 @@
 import fs from "node:fs";
 import path from "node:path";
 import chalk from "chalk";
-import { PACKAGE_ROOT } from "../util.js";
+import { PACKAGE_ROOT } from "../util";
 
 const SKILLS_SRC = path.join(PACKAGE_ROOT, "skills");
 
-const FRAMEWORK_SKILLS = [
-  "1-module-docs",
-  "2-module-feature-breakdown",
-  "3-module-doc-review",
-  "4-module-tdd-implementation",
-  "5-module-implementation-review",
-  "app-compose-1-requirement-analysis",
-  "app-compose-2-requirements-breakdown",
-  "app-compose-3-doc-review",
-  "app-compose-4-design-mock",
-  "app-compose-5-design-mock-review",
-  "app-compose-6-implementation-spec",
-  "mock-scenario",
-];
+function discoverFrameworkSkills(): string[] {
+  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: string,
@@ -55,9 +48,25 @@ export function runInit(cwd: string, force: boolean): number {
 
   // --- Skills ---
   const skillsDest = path.join(cwd, ".agents", "skills");
+
+  // Clean up existing erp-kit-* skills before copying to remove stale names
+  if (force && fs.existsSync(skillsDest)) {
+    let removedCount = 0;
+    for (const entry of fs.readdirSync(skillsDest)) {
+      if (entry.startsWith("erp-kit-")) {
+        fs.rmSync(path.join(skillsDest, entry), { recursive: true, force: true });
+        removedCount++;
+      }
+    }
+    if (removedCount > 0) {
+      console.log(chalk.green(`  Removed ${removedCount} existing erp-kit-* skills`));
+    }
+  }
+
   let copiedCount = 0;
   let skippedCount = 0;
-  for (const skill of FRAMEWORK_SKILLS) {
+  const frameworkSkills = discoverFrameworkSkills();
+  for (const skill of frameworkSkills) {
     const srcSkillDir = path.join(SKILLS_SRC, skill);
     if (!fs.existsSync(srcSkillDir)) continue;
 

package/src/commands/license.ts

@@ -0,0 +1,193 @@
+import fs from "node:fs";
+import { execSync } from "node:child_process";
+
+// License groups based on Google licenseclassifier categories
+// https://github.com/google/licenseclassifier/blob/e6a9bb99b5a6f71d5a34336b8245e305f5430f99/license_type.go
+export const 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"],
+} as const;
+
+export type LicenseGroup = keyof typeof licenseGroups;
+
+interface LicenseConfig {
+  groups: LicenseGroup[];
+  allow?: string[];
+  deny?: string[];
+}
+
+function buildAllowSet(config: LicenseConfig): Set<string> {
+  const set = new Set<string>();
+  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: string, allowSet: Set<string>): boolean {
+  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);
+}
+
+export interface LicenseViolation {
+  package: string;
+  license: string;
+}
+
+export function runLicenseList(): number {
+  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;
+}
+
+export function runLicenseCheck(configPath: string): number {
+  const raw = fs.readFileSync(configPath, "utf-8");
+  const config = JSON.parse(raw) as LicenseConfig;
+
+  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()) as Record<string, { name: string }[]>;
+
+  const violations: LicenseViolation[] = [];
+  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}\n`);
+  }
+  return 1;
+}

package/src/commands/mock/index.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { defineCommand, arg } from "politty";
-import { runMockStart } from "./start.js";
-import { runMockValidate } from "./validate.js";
+import { runMockStart } from "./start";
+import { runMockValidate } from "./validate";
 
 const startCommand = defineCommand({
   name: "start",

package/src/commands/mock/start.ts

@@ -2,7 +2,7 @@ import { createServer, request as httpRequest } from "node:http";
 import { createServer as createNetServer } from "node:net";
 import { existsSync, readdirSync } from "node:fs";
 import { resolve, relative, join } from "node:path";
-import { createMockServer, type MockServer } from "../../mockServer.js";
+import { createMockServer, type MockServer } from "../../mockServer";
 
 interface MockEntry {
   provider: string;

package/src/commands/mock/validate.test.ts

@@ -2,7 +2,7 @@ import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { runMockValidate } from "./validate.js";
+import { runMockValidate } from "./validate";
 
 let tempDir: string;
 

package/src/commands/module/generate.ts

@@ -0,0 +1,35 @@
+import path from "node:path";
+import { defineCommand, arg } from "politty";
+import { z } from "zod";
+import { runGenerateCode } from "../../generator/generate-code";
+
+const cwd = process.cwd();
+
+const 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 = path.resolve(cwd, args.root, args.module);
+    console.log(`Generating code for ${args.module}...`);
+    const exitCode = runGenerateCode(modulePath, args.module);
+    process.exit(exitCode);
+  },
+});
+
+export const generateCommand = defineCommand({
+  name: "generate",
+  description: "Generate code from model definitions and docs",
+  subCommands: {
+    code: codeCommand,
+  },
+});

package/src/commands/module/index.ts

@@ -1,9 +1,10 @@
 import { z } from "zod";
 import { defineCommand, arg } from "politty";
-import { runCheck } from "../check.js";
-import { runSyncCheck, formatSyncCheckReport } from "../sync-check.js";
-import { runScaffold, MODULE_TYPES, type ScaffoldType } from "../scaffold.js";
-import { runModuleList } from "./list.js";
+import { runCheck } from "../check";
+import { runSyncCheck, formatSyncCheckReport } from "../sync-check";
+import { runScaffold, MODULE_TYPES, type ScaffoldType } from "../scaffold";
+import { runModuleList } from "./list";
+import { generateCommand } from "./generate";
 
 const cwd = process.cwd();
 
@@ -81,5 +82,6 @@ export const moduleCommand = defineCommand({
     check: checkCommand,
     "sync-check": syncCheckCommand,
     scaffold: scaffoldCommand,
+    generate: generateCommand,
   },
 });

package/src/commands/module/list.test.ts

@@ -1,8 +1,8 @@
 import { describe, it, expect } from "vitest";
+import { listModules, formatModuleList } from "./list";
 
 describe("listModules", () => {
-  it("returns the built-in modules with counts", async () => {
-    const { listModules } = await import("./list.js");
+  it("returns the built-in modules with counts", () => {
     const modules = listModules();
     expect(modules.length).toBeGreaterThan(0);
 
@@ -13,8 +13,7 @@ describe("listModules", () => {
     expect(primitives!.features).toBeGreaterThan(0);
   });
 
-  it("returns zero counts for stub modules", async () => {
-    const { listModules } = await import("./list.js");
+  it("returns zero counts for stub modules", () => {
     const modules = listModules();
     const inventory = modules.find((m) => m.name === "inventory");
     expect(inventory).toBeDefined();
@@ -23,16 +22,14 @@ describe("listModules", () => {
     expect(inventory!.features).toBe(0);
   });
 
-  it("excludes shared and testing directories", async () => {
-    const { listModules } = await import("./list.js");
+  it("excludes shared and testing directories", () => {
     const modules = listModules();
     const names = modules.map((m) => m.name);
     expect(names).not.toContain("shared");
     expect(names).not.toContain("testing");
   });
 
-  it("returns modules in alphabetical order", async () => {
-    const { listModules } = await import("./list.js");
+  it("returns modules in alphabetical order", () => {
     const modules = listModules();
     const names = modules.map((m) => m.name);
     const sorted = [...names].sort();
@@ -41,8 +38,7 @@ describe("listModules", () => {
 });
 
 describe("formatModuleList", () => {
-  it("formats modules with counts", async () => {
-    const { formatModuleList } = await import("./list.js");
+  it("formats modules with counts", () => {
     const output = formatModuleList([
       { name: "primitives", commands: 14, models: 4, features: 4 },
       { name: "inventory", commands: 0, models: 0, features: 0 },
@@ -55,8 +51,7 @@ describe("formatModuleList", () => {
     expect(output).toContain("2 modules");
   });
 
-  it("handles empty list", async () => {
-    const { formatModuleList } = await import("./list.js");
+  it("handles empty list", () => {
     expect(formatModuleList([])).toBe("No modules found.");
   });
 });

package/src/commands/module/list.ts

@@ -1,7 +1,7 @@
 import { readdirSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import chalk from "chalk";
-import { PACKAGE_ROOT } from "../../util.js";
+import { PACKAGE_ROOT } from "../../util";
 
 const MODULES_DIR = join(PACKAGE_ROOT, "src", "modules");
 const EXCLUDED_DIRS = new Set(["shared", "testing"]);

package/src/commands/scaffold-templates.ts

@@ -0,0 +1,65 @@
+export type TemplateEntry =
+  | { type: "dir"; path: string }
+  | { type: "file"; path: string; content: (moduleName: string) => string };
+
+export function getModuleSrcTemplates(): TemplateEntry[] {
+  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 },
+  ];
+}
+
+const MODULE_TEMPLATE = `export const defineModule = () => {
+  return {
+    db: {},
+    commands: {},
+    queries: {},
+  };
+};
+`;
+
+const INDEX_TEMPLATE = `export { defineModule } from "./module";
+export { permissions, own, all } from "./permissions";
+`;
+
+const ERRORS_TEMPLATE = `import { createDomainError } from "../../shared/internal";\n`;
+
+const TYPES_TEMPLATE = `import type { InferSchema, Selectable, Insertable, Updateable } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export type Schema = InferSchema<DB>;
+`;
+
+const FIXTURES_TEMPLATE = `// Add test fixtures here\n`;
+
+function permissionsTemplate(moduleName: string): string {
+  return `import { definePermissions } from "../shared/internal";
+
+export const { permissions, own, all } = definePermissions("${moduleName}", [] as const);
+`;
+}
+
+function tailorConfigTemplate(moduleName: string): string {
+  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" }],
+);
+`;
+}