@tailor-platform/erp-kit 0.2.0 → 0.2.2

package/src/commands/lib/distribute.test.ts

@@ -0,0 +1,126 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { copySkills, copyWorkflows, copyConfigs, setupSymlink } from "./distribute";
+
+describe("copySkills", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "distribute-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("copies erp-kit-* skills to destination", () => {
+    const result = copySkills(tmpDir);
+    const skillPath = path.join(
+      tmpDir,
+      ".agents",
+      "skills",
+      "erp-kit-module-1-requirements",
+      "SKILL.md",
+    );
+    expect(fs.existsSync(skillPath)).toBe(true);
+    expect(result.copied).toBeGreaterThan(0);
+  });
+
+  it("removes stale erp-kit-* skills before copying", () => {
+    const staleDir = path.join(tmpDir, ".agents", "skills", "erp-kit-old-skill");
+    fs.mkdirSync(staleDir, { recursive: true });
+    fs.writeFileSync(path.join(staleDir, "SKILL.md"), "# Stale");
+    const result = copySkills(tmpDir);
+    expect(fs.existsSync(staleDir)).toBe(false);
+    expect(result.removed).toBe(1);
+  });
+
+  it("preserves non-erp-kit skills", () => {
+    const customDir = path.join(tmpDir, ".agents", "skills", "my-custom-skill");
+    fs.mkdirSync(customDir, { recursive: true });
+    fs.writeFileSync(path.join(customDir, "SKILL.md"), "# Custom");
+    copySkills(tmpDir);
+    expect(fs.readFileSync(path.join(customDir, "SKILL.md"), "utf-8")).toBe("# Custom");
+  });
+});
+
+describe("copyWorkflows", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "distribute-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("copies workflow templates to .github/workflows/", () => {
+    const result = copyWorkflows(tmpDir);
+    const wfPath = path.join(tmpDir, ".github", "workflows", "erp-kit-check.yml");
+    expect(fs.existsSync(wfPath)).toBe(true);
+    expect(result.copied).toBeGreaterThan(0);
+  });
+
+  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");
+    copyWorkflows(tmpDir);
+    const content = fs.readFileSync(path.join(wfDir, "erp-kit-check.yml"), "utf-8");
+    expect(content).not.toBe("# Old");
+  });
+});
+
+describe("copyConfigs", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "distribute-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("copies config files to repo root", () => {
+    const result = copyConfigs(tmpDir);
+    const configPath = path.join(tmpDir, "license.config.json");
+    expect(fs.existsSync(configPath)).toBe(true);
+    expect(result.copied).toBeGreaterThan(0);
+  });
+});
+
+describe("setupSymlink", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "distribute-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("creates .claude/skills symlink", () => {
+    setupSymlink(tmpDir);
+    const claudeSkills = path.join(tmpDir, ".claude", "skills");
+    expect(fs.lstatSync(claudeSkills).isSymbolicLink()).toBe(true);
+    expect(fs.readlinkSync(claudeSkills)).toBe(path.join("..", ".agents", "skills"));
+  });
+
+  it("skips when correct symlink already exists", () => {
+    setupSymlink(tmpDir);
+    const result = setupSymlink(tmpDir);
+    expect(result).toBe("already_linked");
+  });
+
+  it("skips when .claude/skills is a real directory", () => {
+    const claudeSkills = path.join(tmpDir, ".claude", "skills");
+    fs.mkdirSync(claudeSkills, { recursive: true });
+    const result = setupSymlink(tmpDir);
+    expect(result).toBe("skipped_directory");
+  });
+});

package/src/commands/lib/distribute.ts

@@ -0,0 +1,129 @@
+import fs from "node:fs";
+import path from "node:path";
+import { PACKAGE_ROOT } from "../../util";
+
+const SKILLS_SRC = path.join(PACKAGE_ROOT, "skills");
+const WORKFLOWS_SRC = path.join(PACKAGE_ROOT, "templates", "workflows");
+const CONFIG_SRC = path.join(PACKAGE_ROOT, "templates", "config");
+
+export interface CopyResult {
+  copied: number;
+  removed: number;
+}
+
+function copyDirectoryRecursive(srcDir: string, destDir: string): number {
+  let copied = 0;
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copied += copyDirectoryRecursive(srcPath, destPath);
+    } else {
+      fs.mkdirSync(destDir, { recursive: true });
+      fs.copyFileSync(srcPath, destPath);
+      copied++;
+    }
+  }
+  return copied;
+}
+
+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);
+}
+
+export function copySkills(cwd: string): CopyResult {
+  const skillsDest = path.join(cwd, ".agents", "skills");
+
+  let removed = 0;
+  if (fs.existsSync(skillsDest)) {
+    for (const entry of fs.readdirSync(skillsDest)) {
+      if (entry.startsWith("erp-kit-")) {
+        fs.rmSync(path.join(skillsDest, entry), { recursive: true, force: true });
+        removed++;
+      }
+    }
+  }
+
+  let copied = 0;
+  for (const skill of discoverFrameworkSkills()) {
+    const srcSkillDir = path.join(SKILLS_SRC, skill);
+    if (!fs.existsSync(srcSkillDir)) continue;
+    const destDir = path.join(skillsDest, skill);
+    copied += copyDirectoryRecursive(srcSkillDir, destDir);
+  }
+
+  return { copied, removed };
+}
+
+export function copyWorkflows(cwd: string): CopyResult {
+  const workflowsDest = path.join(cwd, ".github", "workflows");
+  if (!fs.existsSync(WORKFLOWS_SRC)) return { copied: 0, removed: 0 };
+
+  const workflowFiles = fs
+    .readdirSync(WORKFLOWS_SRC)
+    .filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+
+  let copied = 0;
+  for (const file of workflowFiles) {
+    fs.mkdirSync(workflowsDest, { recursive: true });
+    fs.copyFileSync(path.join(WORKFLOWS_SRC, file), path.join(workflowsDest, file));
+    copied++;
+  }
+
+  return { copied, removed: 0 };
+}
+
+export function copyConfigs(cwd: string): CopyResult {
+  if (!fs.existsSync(CONFIG_SRC)) return { copied: 0, removed: 0 };
+
+  let copied = 0;
+  for (const entry of fs.readdirSync(CONFIG_SRC)) {
+    const destPath = path.join(cwd, entry);
+    fs.copyFileSync(path.join(CONFIG_SRC, entry), destPath);
+    copied++;
+  }
+
+  return { copied, removed: 0 };
+}
+
+export type SymlinkResult = "linked" | "already_linked" | "skipped_directory";
+
+export function setupSymlink(cwd: string): SymlinkResult {
+  const skillsDest = path.join(cwd, ".agents", "skills");
+  const claudeSkills = path.join(cwd, ".claude", "skills");
+  const relTarget = path.relative(path.dirname(claudeSkills), skillsDest);
+
+  let exists = false;
+  try {
+    fs.lstatSync(claudeSkills);
+    exists = true;
+  } catch {
+    // doesn't exist
+  }
+
+  if (exists) {
+    const stat = fs.lstatSync(claudeSkills);
+    if (stat.isSymbolicLink()) {
+      const current = fs.readlinkSync(claudeSkills);
+      if (current === relTarget) return "already_linked";
+      fs.unlinkSync(claudeSkills);
+      fs.symlinkSync(relTarget, claudeSkills);
+      return "linked";
+    }
+    return "skipped_directory";
+  }
+
+  fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });
+  fs.symlinkSync(relTarget, claudeSkills);
+  return "linked";
+}
+
+export function isAlreadyInitialized(cwd: string): boolean {
+  const skillsDest = path.join(cwd, ".agents", "skills");
+  if (!fs.existsSync(skillsDest)) return false;
+  return fs.readdirSync(skillsDest).some((entry) => entry.startsWith("erp-kit-"));
+}

package/src/commands/parse-doc-test-cases.ts

@@ -0,0 +1,55 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toString } from "mdast-util-to-string";
+import type { Heading, List, RootContent } from "mdast";
+
+function isHeading(node: RootContent): node is Heading {
+  return node.type === "heading";
+}
+
+function isList(node: RootContent): node is List {
+  return node.type === "list";
+}
+
+/**
+ * Parse test case descriptions from the `## Test Cases` section of a Markdown doc.
+ * Uses mdast to traverse the AST instead of string matching.
+ */
+export function parseTestCasesFromDoc(markdown: string): string[] {
+  const tree = fromMarkdown(markdown);
+  const cases: string[] = [];
+  let collecting = false;
+
+  for (const node of tree.children) {
+    if (isHeading(node)) {
+      if (collecting) break;
+      if (node.depth === 2 && toString(node) === "Test Cases") {
+        collecting = true;
+        continue;
+      }
+    }
+    if (collecting && isList(node)) {
+      for (const item of node.children) {
+        const text = toString(item).trim();
+        if (text) {
+          cases.push(text);
+        }
+      }
+    }
+  }
+
+  return cases;
+}
+
+/**
+ * Parse `it("...")` descriptions from a test file using regex.
+ * Test files are not Markdown, so regex is appropriate here.
+ */
+export function parseItDescriptionsFromTest(content: string): string[] {
+  const descriptions: string[] = [];
+  const regex = /\bit\(\s*["'`]([^"'`]+)["'`]/g;
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(content)) !== null) {
+    descriptions.push(match[1]);
+  }
+  return descriptions;
+}

package/src/commands/scaffold.test.ts

@@ -1,17 +1,8 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import {
-  type Diagnostic,
-  DiagnosticCategory,
-  flattenDiagnosticMessageText,
-  ModuleKind,
-  ScriptTarget,
-  transpileModule,
-} from "typescript";
 import { describe, it, expect, afterEach } from "vitest";
-import { resolveScaffoldPath, scaffoldModuleSrc } from "./scaffold";
-import { getModuleSrcTemplates } from "./scaffold-templates";
+import { resolveScaffoldPath, scaffoldModuleSrc, copyTemplateDir } from "./scaffold";
 
 describe("resolveScaffoldPath", () => {
   // Module types
@@ -36,8 +27,8 @@ describe("resolveScaffoldPath", () => {
   });
 
   // App-compose types
-  it("resolves requirements scaffold path", () => {
-    const result = resolveScaffoldPath("requirements", "my-app", undefined, "examples");
+  it("resolves app scaffold path", () => {
+    const result = resolveScaffoldPath("app", "my-app", undefined, "examples");
     expect(result).toBe("examples/my-app/README.md");
   });
 
@@ -144,28 +135,78 @@ describe("scaffoldModuleSrc", () => {
     expect(moduleFile).toContain("commands");
     expect(moduleFile).toContain("queries");
   });
+});
+
+describe("copyTemplateDir", () => {
+  let tmpDir: string;
 
-  it("generates syntactically valid TypeScript for all file templates", () => {
-    const templates = getModuleSrcTemplates();
-    const fileTemplates = templates.filter((t) => t.type === "file");
-
-    for (const entry of fileTemplates) {
-      const source = entry.content("test-module");
-      const result = transpileModule(source, {
-        reportDiagnostics: true,
-        compilerOptions: { target: ScriptTarget.ESNext, module: ModuleKind.ESNext },
-      });
-      const errors = (result.diagnostics ?? []).filter(
-        (d) => d.category === DiagnosticCategory.Error,
-      );
-      expect(
-        errors,
-        `syntax errors in template "${entry.path}": ${formatDiagnostics(errors)}`,
-      ).toHaveLength(0);
+  afterEach(() => {
+    if (tmpDir) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
     }
   });
-});
 
-function formatDiagnostics(diagnostics: Diagnostic[]): string {
-  return diagnostics.map((d) => flattenDiagnosticMessageText(d.messageText, "\n")).join("; ");
-}
+  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");
+
+    // Build a minimal fixture
+    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);
+
+    // 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");
+    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);
+  });
+});

package/src/commands/scaffold.ts

@@ -2,17 +2,10 @@ import path from "node:path";
 import fs from "node:fs";
 import { runMdschema } from "../mdschema";
 import { ALL_SCHEMAS } from "../schemas";
-import { getModuleSrcTemplates } from "./scaffold-templates";
+import { PACKAGE_ROOT, readErpKitVersion } from "../util";
 
 export const MODULE_TYPES = ["module", "feature", "command", "model", "query"] as const;
-export const APP_TYPES = [
-  "requirements",
-  "actors",
-  "business-flow",
-  "story",
-  "screen",
-  "resolver",
-] 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];
@@ -42,7 +35,7 @@ export function resolveScaffoldPath(
   root: string,
 ): string {
   // Types that map to README.md (no name needed)
-  if (type === "module" || type === "requirements") {
+  if (type === "module" || type === "app") {
     return path.join(root, parentName, "README.md");
   }
 
@@ -123,18 +116,61 @@ export async function runScaffold(
     scaffoldModuleSrc(path.dirname(absoluteOutput), parentName);
   }
 
+  if (type === "app") {
+    scaffoldAppSrc(path.dirname(absoluteOutput), parentName);
+  }
+
   return exitCode;
 }
 
-export function scaffoldModuleSrc(moduleDir: string, moduleName: string): void {
-  for (const entry of getModuleSrcTemplates()) {
-    const fullPath = path.join(moduleDir, entry.path);
-    if (entry.type === "dir") {
-      fs.mkdirSync(fullPath, { recursive: true });
-      fs.writeFileSync(path.join(fullPath, ".gitkeep"), "");
+// 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(fullPath), { recursive: true });
-      fs.writeFileSync(fullPath, entry.content(moduleName));
+      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);
+}