@tailor-platform/erp-kit 0.1.1 → 0.2.0

package/src/cli.ts

@@ -1,120 +1,6 @@
 #!/usr/bin/env node
 
-import { z } from "zod";
-import { defineCommand, runMain, arg } from "politty";
-import { runCheck } from "./commands/check.js";
-import { runSyncCheck, formatSyncCheckReport } from "./commands/sync-check.js";
-import { runScaffold, ALL_TYPES, isModuleType, type ScaffoldType } from "./commands/scaffold.js";
-import { runInit } from "./commands/init.js";
-import { mockCommand } from "./commands/mock/index.js";
+import { runMain } from "politty";
+import { mainCommand } from "./commands/index";
 
-const cwd = process.cwd();
-
-const rootArgs = z.object({
-  modulesRoot: arg(z.string().optional(), {
-    alias: "m",
-    description: "Path to modules directory",
-  }),
-  appRoot: arg(z.string().optional(), {
-    alias: "a",
-    description: "Path to app-compose directory (apps/ or examples/)",
-  }),
-});
-
-function requireRoot(args: { modulesRoot?: string; appRoot?: string }) {
-  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;
-}
-
-const checkCommand = defineCommand({
-  name: "check",
-  description: "Validate docs against schemas",
-  args: rootArgs,
-  run: async (args) => {
-    const paths = requireRoot(args);
-    const exitCode = await runCheck(paths, cwd);
-    process.exit(exitCode);
-  },
-});
-
-const syncCheckCommand = defineCommand({
-  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);
-  },
-});
-
-const scaffoldCommand = defineCommand({
-  name: "scaffold",
-  description: "Generate doc file from schema template",
-  args: rootArgs.extend({
-    type: arg(z.enum(ALL_TYPES as unknown as [string, ...string[]]), {
-      positional: true,
-      description: `Scaffold type (${ALL_TYPES.join(", ")})`,
-    }),
-    parent: arg(z.string(), {
-      positional: true,
-      description: "Parent name (module or app name)",
-    }),
-    name: arg(z.string().optional(), {
-      positional: true,
-      description: "Item name (required for most types)",
-    }),
-  }),
-  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 as ScaffoldType,
-      args.parent,
-      args.name,
-      root,
-      cwd,
-    );
-    process.exit(exitCode);
-  },
-});
-
-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 main = defineCommand({
-  name: "erp-kit",
-  description: "Documentation validation and scaffolding tool",
-  subCommands: {
-    check: checkCommand,
-    "sync-check": syncCheckCommand,
-    scaffold: scaffoldCommand,
-    init: initCommand,
-    mock: mockCommand,
-  },
-});
-
-void runMain(main);
+void runMain(mainCommand);

package/src/commands/app/index.ts

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { defineCommand, arg } from "politty";
+import { runCheck } from "../check";
+import { runSyncCheck, formatSyncCheckReport } from "../sync-check";
+import { runScaffold, APP_TYPES, type ScaffoldType } from "../scaffold";
+
+const cwd = process.cwd();
+
+const rootArgs = z.object({
+  root: arg(z.string(), {
+    alias: "r",
+    description: "Path to app-compose directory",
+  }),
+});
+
+const checkCommand = defineCommand({
+  name: "check",
+  description: "Validate app docs against schemas",
+  args: rootArgs,
+  run: async (args) => {
+    const exitCode = await runCheck({ appRoot: args.root }, cwd);
+    process.exit(exitCode);
+  },
+});
+
+const syncCheckCommand = defineCommand({
+  name: "sync-check",
+  description: "Validate source <-> doc correspondence",
+  args: rootArgs,
+  run: async (args) => {
+    const result = await runSyncCheck({ appRoot: args.root }, cwd);
+    console.log(formatSyncCheckReport(result));
+    process.exit(result.exitCode);
+  },
+});
+
+const scaffoldCommand = defineCommand({
+  name: "scaffold",
+  description: "Generate app doc from schema template",
+  args: rootArgs.extend({
+    type: arg(z.enum(APP_TYPES as unknown as [string, ...string[]]), {
+      positional: true,
+      description: `Scaffold type (${APP_TYPES.join(", ")})`,
+    }),
+    parent: arg(z.string(), {
+      positional: true,
+      description: "App name",
+    }),
+    name: arg(z.string().optional(), {
+      positional: true,
+      description: "Item name (required for most types)",
+    }),
+  }),
+  run: async (args) => {
+    const exitCode = await runScaffold(
+      args.type as ScaffoldType,
+      args.parent,
+      args.name,
+      args.root,
+      cwd,
+    );
+    process.exit(exitCode);
+  },
+});
+
+export const appCommand = defineCommand({
+  name: "app",
+  description: "App-compose management",
+  subCommands: {
+    check: checkCommand,
+    "sync-check": syncCheckCommand,
+    scaffold: scaffoldCommand,
+  },
+});

package/src/commands/check.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { buildCheckTargets } from "./check.js";
+import { buildCheckTargets } from "./check";
 
 describe("buildCheckTargets", () => {
   it("generates module targets when modulesRoot is set", () => {
@@ -8,6 +8,7 @@ describe("buildCheckTargets", () => {
       { glob: "modules/[a-zA-Z]*/docs/features/*.md", schemaKey: "feature" },
       { glob: "modules/[a-zA-Z]*/docs/commands/*.md", schemaKey: "command" },
       { glob: "modules/[a-zA-Z]*/docs/models/*.md", schemaKey: "model" },
+      { glob: "modules/[a-zA-Z]*/docs/queries/*.md", schemaKey: "query" },
       { glob: "modules/[a-zA-Z]*/README.md", schemaKey: "module" },
     ]);
   });
@@ -20,7 +21,7 @@ describe("buildCheckTargets", () => {
 
   it("generates both when both roots are set", () => {
     const targets = buildCheckTargets({ modulesRoot: "modules", appRoot: "examples" });
-    expect(targets).toHaveLength(10);
+    expect(targets).toHaveLength(11);
   });
 
   it("returns empty when neither root is set", () => {

package/src/commands/check.ts

@@ -1,5 +1,5 @@
-import { runMdschema } from "../mdschema.js";
-import { ALL_SCHEMAS } from "../schemas.js";
+import { runMdschema } from "../mdschema";
+import { ALL_SCHEMAS } from "../schemas";
 export interface CheckTarget {
   glob: string;
   schemaKey: string;
@@ -17,6 +17,7 @@ export 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" },
     );
   }

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;