@tailor-platform/erp-kit 0.2.0 → 0.2.2

package/src/commands/sync-check.test.ts

@@ -3,6 +3,7 @@ import os from "node:os";
 import fs from "node:fs";
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { runSyncCheck, checkStaleness } from "./sync-check";
+import { parseTestCasesFromDoc, parseItDescriptionsFromTest } from "./parse-doc-test-cases";
 
 describe("runSyncCheck", () => {
   let tmpDir: string;
@@ -178,6 +179,178 @@ describe("runSyncCheck", () => {
   });
 });
 
+describe("parseTestCasesFromDoc", () => {
+  it("extracts test cases from ## Test Cases section", () => {
+    const content = `# CreateProduct
+
+## Error Scenarios
+
+- **DUPLICATE_CODE**: A product with the same code already exists
+
+## Test Cases
+
+- returns error when code is empty
+- creates product in DRAFT status
+- passes custom fields through
+`;
+    const cases = parseTestCasesFromDoc(content);
+    expect(cases).toEqual([
+      "returns error when code is empty",
+      "creates product in DRAFT status",
+      "passes custom fields through",
+    ]);
+  });
+
+  it("returns empty array when no Test Cases section", () => {
+    const content = `# CreateProduct\n\n## Overview\n\nSome text.`;
+    expect(parseTestCasesFromDoc(content)).toEqual([]);
+  });
+
+  it("stops at next ## heading", () => {
+    const content = `## Test Cases
+
+- case one
+- case two
+
+## Other Section
+
+- not a test case
+`;
+    expect(parseTestCasesFromDoc(content)).toEqual(["case one", "case two"]);
+  });
+});
+
+describe("parseItDescriptionsFromTest", () => {
+  it("extracts it() descriptions from test file", () => {
+    const content = `
+describe("createProduct", () => {
+  it("returns error when code is empty", async () => {});
+  it("creates product in DRAFT status", async () => {});
+  it('passes custom fields through', async () => {});
+});`;
+    const descriptions = parseItDescriptionsFromTest(content);
+    expect(descriptions).toEqual([
+      "returns error when code is empty",
+      "creates product in DRAFT status",
+      "passes custom fields through",
+    ]);
+  });
+
+  it("returns empty array when no it() blocks", () => {
+    expect(parseItDescriptionsFromTest("const x = 1;")).toEqual([]);
+  });
+});
+
+describe("runSyncCheck test-case sync", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sync-check-tc-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("reports missing-test-case when doc has case not in test", async () => {
+    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
+    const testDir = path.join(tmpDir, "modules", "foo", "command");
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.mkdirSync(testDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(docDir, "CreateOrder.md"),
+      "# CreateOrder\n\n## Test Cases\n\n- creates order\n- validates input\n",
+    );
+    fs.writeFileSync(path.join(testDir, "createOrder.ts"), "export {}");
+    fs.writeFileSync(
+      path.join(testDir, "createOrder.test.ts"),
+      'describe("createOrder", () => { it("creates order", async () => {}); });',
+    );
+
+    const result = await runSyncCheck({ modulesRoot: "modules" }, tmpDir);
+    expect(result.errors).toContainEqual(
+      expect.objectContaining({
+        type: "missing-test-case",
+        category: "command-test-case",
+        expectedBasename: "validates input",
+      }),
+    );
+  });
+
+  it("reports extra-test-case when test has case not in doc", async () => {
+    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
+    const testDir = path.join(tmpDir, "modules", "foo", "command");
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.mkdirSync(testDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(docDir, "CreateOrder.md"),
+      "# CreateOrder\n\n## Test Cases\n\n- creates order\n",
+    );
+    fs.writeFileSync(path.join(testDir, "createOrder.ts"), "export {}");
+    fs.writeFileSync(
+      path.join(testDir, "createOrder.test.ts"),
+      'describe("createOrder", () => { it("creates order", async () => {}); it("extra case", async () => {}); });',
+    );
+
+    const result = await runSyncCheck({ modulesRoot: "modules" }, tmpDir);
+    expect(result.errors).toContainEqual(
+      expect.objectContaining({
+        type: "extra-test-case",
+        category: "command-test-case",
+        expectedBasename: "extra case",
+      }),
+    );
+  });
+
+  it("returns 0 when doc test cases match test it() descriptions", async () => {
+    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
+    const testDir = path.join(tmpDir, "modules", "foo", "command");
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.mkdirSync(testDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(docDir, "CreateOrder.md"),
+      "# CreateOrder\n\n## Test Cases\n\n- creates order\n- validates input\n",
+    );
+    fs.writeFileSync(path.join(testDir, "createOrder.ts"), "export {}");
+    fs.writeFileSync(
+      path.join(testDir, "createOrder.test.ts"),
+      'describe("createOrder", () => { it("creates order", async () => {}); it("validates input", async () => {}); });',
+    );
+
+    const result = await runSyncCheck({ modulesRoot: "modules" }, tmpDir);
+    const tcErrors = result.errors.filter(
+      (e) => e.type === "missing-test-case" || e.type === "extra-test-case",
+    );
+    expect(tcErrors).toHaveLength(0);
+  });
+
+  it("skips test-case check when doc has no Test Cases section", async () => {
+    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
+    const testDir = path.join(tmpDir, "modules", "foo", "command");
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.mkdirSync(testDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(docDir, "CreateOrder.md"),
+      "# CreateOrder\n\n## Overview\n\nSome text.\n",
+    );
+    fs.writeFileSync(path.join(testDir, "createOrder.ts"), "export {}");
+    fs.writeFileSync(
+      path.join(testDir, "createOrder.test.ts"),
+      'describe("createOrder", () => { it("creates order", async () => {}); });',
+    );
+
+    const result = await runSyncCheck({ modulesRoot: "modules" }, tmpDir);
+    const tcErrors = result.errors.filter(
+      (e) => e.type === "missing-test-case" || e.type === "extra-test-case",
+    );
+    expect(tcErrors).toHaveLength(0);
+  });
+});
+
 describe("checkStaleness", () => {
   it("reports stale when doc mtime > generated mtime", () => {
     const errors = checkStaleness(

package/src/commands/sync-check.ts

@@ -1,6 +1,8 @@
 import path from "node:path";
+import fs from "node:fs";
 import fg from "fast-glob";
 import chalk from "chalk";
+import { parseTestCasesFromDoc, parseItDescriptionsFromTest } from "./parse-doc-test-cases";
 
 interface CategoryConfig {
   name: string;
@@ -10,7 +12,7 @@ interface CategoryConfig {
 }
 
 export interface CheckError {
-  type: "missing-doc" | "orphaned-doc";
+  type: "missing-doc" | "orphaned-doc" | "missing-test-case" | "extra-test-case";
   category: string;
   sourcePath?: string;
   docPath?: string;
@@ -129,6 +131,11 @@ export async function runSyncCheck(
     totalDocs += docBasenames.size;
   }
 
+  if (config.modulesRoot) {
+    const testCaseErrors = await runTestCaseSyncCheck(config.modulesRoot, cwd);
+    errors.push(...testCaseErrors);
+  }
+
   return {
     exitCode: errors.length > 0 ? 1 : 0,
     errors,
@@ -140,6 +147,90 @@ export async function runSyncCheck(
   };
 }
 
+interface TestCaseCategoryConfig {
+  name: string;
+  docPattern: string;
+  testDir: string;
+}
+
+function testCaseCategories(root: string): TestCaseCategoryConfig[] {
+  return [
+    {
+      name: "command-test-case",
+      docPattern: `${root}/*/docs/commands/*.md`,
+      testDir: "command",
+    },
+    {
+      name: "query-test-case",
+      docPattern: `${root}/*/docs/queries/*.md`,
+      testDir: "query",
+    },
+  ];
+}
+
+function toCamelCase(pascalCase: string): string {
+  return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
+}
+
+async function runTestCaseSyncCheck(root: string, cwd: string): Promise<CheckError[]> {
+  const errors: CheckError[] = [];
+  const categories = testCaseCategories(root);
+
+  for (const category of categories) {
+    const docPaths = await fg(category.docPattern, { cwd });
+
+    for (const docPath of docPaths) {
+      const docFullPath = path.join(cwd, docPath);
+      const docContent = fs.readFileSync(docFullPath, "utf-8");
+      const docTestCases = parseTestCasesFromDoc(docContent);
+
+      if (docTestCases.length === 0) continue;
+
+      const docBasename = path.basename(docPath, ".md");
+      const docsIndex = docPath.indexOf("/docs/");
+      if (docsIndex === -1) continue;
+      const modulePath = docPath.substring(0, docsIndex);
+      const testFileName = `${toCamelCase(docBasename)}.test.ts`;
+      const testPath = path.join(modulePath, category.testDir, testFileName);
+      const testFullPath = path.join(cwd, testPath);
+
+      if (!fs.existsSync(testFullPath)) continue;
+
+      const testContent = fs.readFileSync(testFullPath, "utf-8");
+      const itDescriptions = parseItDescriptionsFromTest(testContent);
+
+      const docSet = new Set(docTestCases);
+      const testSet = new Set(itDescriptions);
+
+      for (const docCase of docSet) {
+        if (!testSet.has(docCase)) {
+          errors.push({
+            type: "missing-test-case",
+            category: category.name,
+            docPath,
+            sourcePath: testPath,
+            expectedBasename: docCase,
+          });
+        }
+      }
+
+      for (const testCase of testSet) {
+        if (!docSet.has(testCase)) {
+          errors.push({
+            type: "extra-test-case",
+            category: category.name,
+            docPath,
+            sourcePath: testPath,
+            expectedBasename: testCase,
+          });
+        }
+      }
+    }
+  }
+
+  return errors;
+}
+
 export interface StalenessError {
   type: "stale-generation";
   docPath: string;
@@ -188,11 +279,21 @@ export function formatSyncCheckReport(result: SyncCheckResult): string {
         if (error.type === "missing-doc") {
           lines.push(`  ${chalk.red(error.sourcePath)}`);
           lines.push(`    ${chalk.yellow("Missing documentation for:")} ${error.expectedBasename}`);
-        } else {
+        } else if (error.type === "orphaned-doc") {
           lines.push(`  ${chalk.red(error.docPath)}`);
           lines.push(
             `    ${chalk.yellow("Orphaned documentation:")} no source file for ${error.expectedBasename}`,
           );
+        } else if (error.type === "missing-test-case") {
+          lines.push(`  ${chalk.red(error.sourcePath)}`);
+          lines.push(
+            `    ${chalk.yellow("Missing test case:")} "${error.expectedBasename}" is in doc but not in test`,
+          );
+        } else if (error.type === "extra-test-case") {
+          lines.push(`  ${chalk.red(error.sourcePath)}`);
+          lines.push(
+            `    ${chalk.yellow("Extra test case:")} "${error.expectedBasename}" is in test but not in doc`,
+          );
         }
         lines.push("");
       }

package/src/commands/update.test.ts

@@ -0,0 +1,87 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { runUpdate } from "./update";
+
+describe("runUpdate", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "update-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("updates skills and workflows by default", () => {
+    const exitCode = runUpdate(tmpDir, []);
+    expect(exitCode).toBe(0);
+
+    const skillPath = path.join(
+      tmpDir,
+      ".agents",
+      "skills",
+      "erp-kit-module-1-requirements",
+      "SKILL.md",
+    );
+    expect(fs.existsSync(skillPath)).toBe(true);
+
+    const wfPath = path.join(tmpDir, ".github", "workflows", "erp-kit-check.yml");
+    expect(fs.existsSync(wfPath)).toBe(true);
+  });
+
+  it("updates only skills when specified", () => {
+    const exitCode = runUpdate(tmpDir, ["skills"]);
+    expect(exitCode).toBe(0);
+
+    const skillPath = path.join(
+      tmpDir,
+      ".agents",
+      "skills",
+      "erp-kit-module-1-requirements",
+      "SKILL.md",
+    );
+    expect(fs.existsSync(skillPath)).toBe(true);
+
+    const wfPath = path.join(tmpDir, ".github", "workflows", "erp-kit-check.yml");
+    expect(fs.existsSync(wfPath)).toBe(false);
+  });
+
+  it("updates only workflows when specified", () => {
+    const exitCode = runUpdate(tmpDir, ["workflows"]);
+    expect(exitCode).toBe(0);
+
+    const skillsDest = path.join(tmpDir, ".agents", "skills");
+    expect(fs.existsSync(skillsDest)).toBe(false);
+
+    const wfPath = path.join(tmpDir, ".github", "workflows", "erp-kit-check.yml");
+    expect(fs.existsSync(wfPath)).toBe(true);
+  });
+
+  it("removes stale skills and replaces with current", () => {
+    const staleDir = path.join(tmpDir, ".agents", "skills", "erp-kit-old-skill");
+    fs.mkdirSync(staleDir, { recursive: true });
+    fs.writeFileSync(path.join(staleDir, "SKILL.md"), "# Stale");
+    runUpdate(tmpDir, ["skills"]);
+    expect(fs.existsSync(staleDir)).toBe(false);
+  });
+
+  it("overwrites existing workflows", () => {
+    const wfDir = path.join(tmpDir, ".github", "workflows");
+    fs.mkdirSync(wfDir, { recursive: true });
+    fs.writeFileSync(path.join(wfDir, "erp-kit-check.yml"), "# Old");
+    runUpdate(tmpDir, ["workflows"]);
+    const content = fs.readFileSync(path.join(wfDir, "erp-kit-check.yml"), "utf-8");
+    expect(content).toContain("@tailor-platform/erp-kit");
+  });
+
+  it("never touches config files", () => {
+    const configPath = path.join(tmpDir, "license.config.json");
+    fs.writeFileSync(configPath, '{"groups": ["notice"]}');
+    runUpdate(tmpDir, []);
+    const config = JSON.parse(fs.readFileSync(configPath, "utf-8")) as { groups: string[] };
+    expect(config.groups).toEqual(["notice"]);
+  });
+});

package/src/commands/update.ts

@@ -0,0 +1,41 @@
+import chalk from "chalk";
+import { copySkills, copyWorkflows } from "./lib/distribute";
+
+export const VALID_RESOURCES = ["skills", "workflows"] as const;
+export type Resource = (typeof VALID_RESOURCES)[number];
+
+export function runUpdate(cwd: string, resources: string[]): number {
+  console.log(chalk.bold("erp-kit update\n"));
+
+  const selected: Set<Resource> =
+    resources.length === 0
+      ? new Set(VALID_RESOURCES)
+      : new Set(
+          resources.filter((r): r is Resource =>
+            (VALID_RESOURCES as readonly string[]).includes(r),
+          ),
+        );
+
+  if (selected.size === 0) {
+    console.error(chalk.red(`Invalid resource. Valid: ${VALID_RESOURCES.join(", ")}`));
+    return 1;
+  }
+
+  if (selected.has("skills")) {
+    const result = copySkills(cwd);
+    if (result.removed > 0) {
+      console.log(chalk.green(`  Removed ${result.removed} stale erp-kit-* skills`));
+    }
+    console.log(chalk.green(`  Copied ${result.copied} skill files to .agents/skills/`));
+  }
+
+  if (selected.has("workflows")) {
+    const result = copyWorkflows(cwd);
+    if (result.copied > 0) {
+      console.log(chalk.green(`  Copied ${result.copied} workflow(s) to .github/workflows/`));
+    }
+  }
+
+  console.log(chalk.bold.green("\nDone!"));
+  return 0;
+}

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

@@ -6,11 +6,21 @@ import {
   generateQueryShell,
   generateQueryStub,
   generateQueryTestStub,
+  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 +40,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 +66,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 +78,7 @@ describe("generateErrors", () => {
       { commandName: "noop", errors: [], externalDependencies: [] },
     ];
 
-    const result = generateErrors(docs);
+    const result = generateErrors("item-management", docs);
 
     expect(result).toBe("");
   });
@@ -80,7 +91,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 +127,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 +144,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 +163,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 +179,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(
@@ -189,7 +200,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"');