@tailor-platform/erp-kit 0.2.0 → 0.2.2

package/skills/erp-kit-module-shared/references/queries.md

@@ -8,7 +8,7 @@ Run `erp-kit module generate code` to generate query shells from `docs/queries/*
 
 ```typescript
 // @generated — do not edit
-import { defineQuery } from "../../shared/internal";
+import { defineQuery } from "../../../shared";
 import { run } from "./getItem";
 
 export const getItem = defineQuery(run);
@@ -17,7 +17,8 @@ export const getItem = defineQuery(run);
 ### Hand-written implementation
 
 ```typescript
-import type { ReadonlyDB } from "../../shared/internal";
+import type { ReadonlyDB } from "../../../shared";
+import { ok } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export type GetItemInput = { id: string } | { sku: string };
@@ -32,42 +33,96 @@ export async function run(db: ReadonlyDB<DB>, input: GetItemInput) {
   }
 
   const item = await query.executeTakeFirst();
-  return { item: item ?? null };
+  return ok({ item: item ?? null });
 }
 ```
 
 ## Custom Queries
 
-For queries beyond simple lookups (joins, aggregations, complex filters), write them by hand in `query/*.ts`:
+For queries beyond simple lookups (joins, aggregations, complex filters), write them by hand in `query/*.ts`. List queries must use pagination — see [Paginated List Queries](#paginated-list-queries) for the full pattern.
+
+## Conventions
+
+- `defineQuery` wraps all queries via generated shells
+- `ReadonlyDB<DB>` ensures read-only access
+- All queries return Result types using `ok()` / `err()` from `shared` — consistent with commands
+- Get queries return `ok({ entity: T | null })` using `executeTakeFirst()`
+- List queries return `ok(PaginatedResult<T>)` using pagination utilities — see [Paginated List Queries](#paginated-list-queries)
+- Input types: `type` for union inputs (get), `interface` for single-shape inputs (list)
+- `.generated.ts` files are always overwritten — never edit them
+
+## Paginated List Queries
+
+All list queries use offset/limit pagination via shared utilities. This is the standard for ERP module-level APIs.
+
+### Types
+
+```typescript
+// PaginationInput accepts a generic TOrderBy for per-query sortable fields.
+// "id" is always available as a sort field.
+interface PaginationInput<TOrderBy extends string = never> {
+  limit?: number; // default: 20 (DEFAULT_PAGE_SIZE)
+  offset?: number; // default: 0
+  orderBy?: "id" | TOrderBy; // default: "id"
+  orderDirection?: "asc" | "desc"; // default: "asc"
+}
+
+interface PaginatedResult<T> {
+  items: T[];
+  total?: number; // optional — caller opts in to COUNT(*) overhead
+  hasNextPage: boolean;
+}
+```
+
+### Pattern
+
+1. Extend `PaginationInput<T>` with query-specific sortable fields
+2. Apply `.orderBy()`, `.limit(limit + 1)`, `.offset()` to the Kysely query
+3. Use `buildPaginatedResult(rows, limit)` to build the response — the limit+1 strategy determines `hasNextPage` without a separate count query
 
 ```typescript
-import type { ReadonlyDB } from "../../shared/internal";
+import {
+  ok,
+  type ReadonlyDB,
+  type PaginationInput,
+  buildPaginatedResult,
+  DEFAULT_PAGE_SIZE,
+} from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
-export interface ListActiveItemsByCategoryInput {
+// Define sortable fields for this query
+type UnitOrderByField = "name" | "symbol" | "createdAt";
+
+export interface ListUnitsByCategoryInput extends PaginationInput<UnitOrderByField> {
   categoryId: string;
 }
 
-export async function run(db: ReadonlyDB<DB>, input: ListActiveItemsByCategoryInput) {
-  const items = await db
-    .selectFrom("Item")
+export async function run(db: ReadonlyDB<DB>, input: ListUnitsByCategoryInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+  const orderBy = input.orderBy ?? "id";
+  const orderDirection = input.orderDirection ?? "asc";
+
+  const units = await db
+    .selectFrom("Unit")
     .selectAll()
     .where("categoryId", "=", input.categoryId)
-    .where("status", "=", "ACTIVE")
+    .orderBy(orderBy, orderDirection)
+    .limit(limit + 1)
+    .offset(offset)
     .execute();
 
-  return { items };
+  return ok(buildPaginatedResult(units, limit));
 }
 ```
 
-## Conventions
+### Rules
 
-- `defineQuery` wraps all queries via generated shells
-- `ReadonlyDB<DB>` ensures read-only access
-- Get queries return `{ entity: T | null }` using `executeTakeFirst()`
-- List queries return `{ entities: T[] }` using `execute()`
-- Input types: `type` for union inputs (get), `interface` for single-shape inputs (list)
-- `.generated.ts` files are always overwritten — never edit them
+- Every list query must extend `PaginationInput` — no unbounded result sets
+- Define a `TOrderBy` type alias with the query's sortable columns (exclude `id` — it's always included)
+- Default sort is `"id" asc` — deterministic ordering is required for stable pagination
+- Use `limit + 1` fetch strategy — never issue a separate `COUNT(*)` unless the caller explicitly needs `total`
+- Queries with no custom sort fields use plain `PaginationInput` (only `"id"` is sortable)
 
 ## Status-Aware Query Rules
 
@@ -86,43 +141,47 @@ Models with a status lifecycle (Stateful models with `status` enum, or simple mo
 
 ```typescript
 // Business use case — status baked into the name
-export async function run(db: ReadonlyDB<DB>, input: ListActiveItemsByCategoryInput) {
-  const items = await db
-    .selectFrom("Item")
-    .selectAll()
-    .where("categoryId", "=", input.categoryId)
-    .where("status", "=", "ACTIVE")
-    .execute();
-  return { items };
+// List queries use pagination (see Paginated List Queries section)
+export interface ListActiveItemsByCategoryInput extends PaginationInput {
+  categoryId: string;
 }
 
-// Unfiltered — no status filter, returns everything
-export async function run(db: ReadonlyDB<DB>, input: ListItemsByCategoryInput) {
+export async function run(db: ReadonlyDB<DB>, input: ListActiveItemsByCategoryInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+
   const items = await db
     .selectFrom("Item")
     .selectAll()
     .where("categoryId", "=", input.categoryId)
+    .where("status", "=", "ACTIVE")
+    .orderBy(input.orderBy ?? "id", input.orderDirection ?? "asc")
+    .limit(limit + 1)
+    .offset(offset)
     .execute();
-  return { items };
+  return ok(buildPaginatedResult(items, limit));
 }
 
-// Single lookup — status-unaware, returns any status
+// Single lookup — status-unaware, returns any status (no pagination)
 export async function run(db: ReadonlyDB<DB>, input: GetItemInput) {
   const item = await db
     .selectFrom("Item")
     .selectAll()
     .where("id", "=", input.id)
     .executeTakeFirst();
-  return { item: item ?? null };
+  return ok({ item: item ?? null });
 }
 
-// Admin/exploratory — parametric status filter
-export interface SearchItemsInput {
+// Admin/exploratory — parametric status filter with pagination
+export interface SearchItemsInput extends PaginationInput {
   status?: string;
   categoryId?: string;
 }
 
 export async function run(db: ReadonlyDB<DB>, input: SearchItemsInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+
   let query = db.selectFrom("Item").selectAll();
   if (input.status) {
     query = query.where("status", "=", input.status);
@@ -130,8 +189,12 @@ export async function run(db: ReadonlyDB<DB>, input: SearchItemsInput) {
   if (input.categoryId) {
     query = query.where("categoryId", "=", input.categoryId);
   }
-  const items = await query.execute();
-  return { items };
+  const items = await query
+    .orderBy(input.orderBy ?? "id", input.orderDirection ?? "asc")
+    .limit(limit + 1)
+    .offset(offset)
+    .execute();
+  return ok(buildPaginatedResult(items, limit));
 }
 ```
 
@@ -142,14 +205,24 @@ The same naming rules apply. For models using `isActive` instead of a `status` e
 ```typescript
 // Business use case — active units only
 // listActiveUnitsByCategory
+export interface ListActiveUnitsByCategoryInput extends PaginationInput {
+  categoryId: string;
+}
+
 export async function run(db: ReadonlyDB<DB>, input: ListActiveUnitsByCategoryInput) {
+  const limit = input.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = input.offset ?? 0;
+
   const units = await db
     .selectFrom("Unit")
     .selectAll()
     .where("categoryId", "=", input.categoryId)
     .where("isActive", "=", true)
+    .orderBy(input.orderBy ?? "id", input.orderDirection ?? "asc")
+    .limit(limit + 1)
+    .offset(offset)
     .execute();
-  return { units };
+  return ok(buildPaginatedResult(units, limit));
 }
 ```
 

package/skills/erp-kit-module-shared/references/testing.md

@@ -29,6 +29,16 @@ For commands with generic `CF`, add one test verifying custom fields reach `.val
 - Assert with `spies.values`: `expect(spies.values).toHaveBeenNthCalledWith(1, expect.objectContaining({ myField: "value" }))`
 - Use `toHaveBeenNthCalledWith(n, ...)` when multiple inserts occur (e.g., audit events)
 
+## Test Case Documentation Sync
+
+Command and query docs include a `## Test Cases` section listing each `it()` description. This list must stay in sync with the actual test file:
+
+- Each `it("...")` in the test file must appear as `- ...` in the doc's `## Test Cases`
+- Each item in `## Test Cases` must have a corresponding `it()` in the test file
+- Run `erp-kit module sync-check` to verify alignment
+- When adding a new test, add the `it()` description to the doc first, then write the test
+- Test case descriptions should match the doc's Process Flow branches and Error Scenarios
+
 ## Fixtures (`testing/fixtures.ts`)
 
 - Import `Schema` from `lib/types` (not `Namespace` from generated code)

package/skills/erp-kit-update/SKILL.md

@@ -31,7 +31,7 @@ Dynamically discover available erp-kit skills:
 1. Glob for `erp-kit-app-*/SKILL.md` or `erp-kit-module-*/SKILL.md` files (based on domain from Phase 1) in the skills directory
 2. Read each SKILL.md's frontmatter `name` and `description`
 3. Skip `erp-kit-module-shared` (not directly invocable)
-4. Sort skills by their numeric step (extract number from name, e.g. `erp-kit-app-2-breakdown` → step 2)
+4. Sort skills by their numeric step (extract number from name, e.g. `erp-kit-app-3-plan` → step 3)
 
 This builds the routing table at runtime — new or renamed skills are picked up automatically.
 
@@ -53,7 +53,7 @@ Only list downstream skills that are plausibly affected by the change.
 
 Use the `Skill` tool to invoke the routed skill. Pass the app or module name as the argument.
 
-Example: `Skill: erp-kit-app-2-breakdown, args: "inventory-management"`
+Example: `Skill: erp-kit-app-3-plan, args: "inventory-management"`
 
 ## Multiple Changes
 

package/src/app.ts

@@ -1 +1 @@
-export { createContext } from "./modules/shared/createContext";
+export { createContext } from "./shared/createContext";

package/src/commands/check.ts

@@ -25,7 +25,7 @@ export function buildCheckTargets(config: {
   if (config.appRoot) {
     const a = config.appRoot;
     targets.push(
-      { glob: `${a}/[a-zA-Z]*/README.md`, schemaKey: "requirements" },
+      { glob: `${a}/[a-zA-Z]*/README.md`, schemaKey: "app" },
       { glob: `${a}/[a-zA-Z]*/docs/actors/*.md`, schemaKey: "actors" },
       { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/README.md`, schemaKey: "business-flow" },
       { glob: `${a}/[a-zA-Z]*/docs/business-flow/*/story/*.md`, schemaKey: "story" },

package/src/commands/index.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { defineCommand, arg } from "politty";
 import { runInit } from "./init";
+import { runUpdate } from "./update";
 import { runLicenseCheck, runLicenseList } from "./license";
 import { moduleCommand } from "./module/index";
 import { appCommand } from "./app/index";
@@ -14,15 +15,24 @@ const cwd = process.cwd();
 
 export const initCommand = defineCommand({
   name: "init",
-  description: "Set up consumer repo with framework skills",
+  description: "First-time setup for a consumer repo",
+  run: () => {
+    const exitCode = runInit(cwd);
+    process.exit(exitCode);
+  },
+});
+
+export const updateCommand = defineCommand({
+  name: "update",
+  description: "Refresh framework-managed resources (skills, workflows)",
   args: z.object({
-    force: arg(z.boolean().default(false), {
-      alias: "f",
-      description: "Overwrite existing skills",
+    resources: arg(z.array(z.string()).default([]), {
+      positional: true,
+      description: "Resources to update (skills, workflows). Defaults to all.",
     }),
   }),
   run: (args) => {
-    const exitCode = runInit(cwd, args.force);
+    const exitCode = runUpdate(cwd, args.resources);
     process.exit(exitCode);
   },
 });
@@ -68,6 +78,7 @@ export const mainCommand = defineCommand({
     app: appCommand,
     mock: mockCommand,
     init: initCommand,
+    update: updateCommand,
     license: licenseCommand,
   },
 });

package/src/commands/init.test.ts

@@ -15,91 +15,44 @@ describe("runInit", () => {
     fs.rmSync(tmpDir, { recursive: true, force: true });
   });
 
-  it("copies framework skills to .agents/skills/", () => {
-    runInit(tmpDir, false);
-    const skillPath = path.join(tmpDir, ".agents", "skills", "erp-kit-module-1-docs", "SKILL.md");
-    expect(fs.existsSync(skillPath)).toBe(true);
-  });
+  it("copies skills, workflows, config, and symlink on fresh repo", () => {
+    const exitCode = runInit(tmpDir);
+    expect(exitCode).toBe(0);
 
-  it("copies skill references/ directories", () => {
-    runInit(tmpDir, false);
-    const refPath = path.join(
+    // Skills
+    const skillPath = path.join(
       tmpDir,
       ".agents",
       "skills",
-      "erp-kit-module-4-tdd",
-      "references",
-      "models.md",
+      "erp-kit-module-1-requirements",
+      "SKILL.md",
     );
-    expect(fs.existsSync(refPath)).toBe(true);
-
-    const content = fs.readFileSync(refPath, "utf-8");
-    expect(content).toContain("# Database Models");
-  });
-
-  it("does not overwrite project-specific skills", () => {
-    const customSkillDir = path.join(tmpDir, ".agents", "skills", "my-custom-skill");
-    fs.mkdirSync(customSkillDir, { recursive: true });
-    fs.writeFileSync(path.join(customSkillDir, "SKILL.md"), "# Custom");
-    runInit(tmpDir, false);
-    const content = fs.readFileSync(path.join(customSkillDir, "SKILL.md"), "utf-8");
-    expect(content).toBe("# Custom");
-  });
-
-  it("does not overwrite existing framework skills", () => {
-    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);
-    const content = fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf-8");
-    expect(content).toBe("# Customized");
-  });
-
-  it("overwrites existing framework skills with --force", () => {
-    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);
-    const content = fs.readFileSync(path.join(skillDir, "SKILL.md"), "utf-8");
-    expect(content).not.toBe("# Customized");
-  });
+    expect(fs.existsSync(skillPath)).toBe(true);
 
-  it("creates .claude/skills symlink to .agents/skills", () => {
-    runInit(tmpDir, false);
+    // Symlink
     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 symlink when .claude/skills is a real directory", () => {
-    const claudeSkills = path.join(tmpDir, ".claude", "skills");
-    fs.mkdirSync(claudeSkills, { recursive: true });
-    runInit(tmpDir, false);
-    expect(fs.lstatSync(claudeSkills).isSymbolicLink()).toBe(false);
+    // Workflows
+    const wfPath = path.join(tmpDir, ".github", "workflows", "erp-kit-check.yml");
+    expect(fs.existsSync(wfPath)).toBe(true);
+
+    // Config
+    const configPath = path.join(tmpDir, "license.config.json");
+    expect(fs.existsSync(configPath)).toBe(true);
   });
 
-  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("refuses to run if already initialized", () => {
+    runInit(tmpDir);
+    const exitCode = runInit(tmpDir);
+    expect(exitCode).toBe(1);
   });
 
-  it("preserves non-erp-kit skills with --force", () => {
+  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");
-    runInit(tmpDir, true);
-    expect(fs.existsSync(path.join(customDir, "SKILL.md"))).toBe(true);
+    runInit(tmpDir);
     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 });
-    fs.symlinkSync("../old-target", claudeSkills);
-    runInit(tmpDir, true);
-    expect(fs.readlinkSync(claudeSkills)).toBe(path.join("..", ".agents", "skills"));
-  });
 });

package/src/commands/init.ts

@@ -1,127 +1,40 @@
-import fs from "node:fs";
-import path from "node:path";
 import chalk from "chalk";
-import { PACKAGE_ROOT } from "../util";
-
-const SKILLS_SRC = path.join(PACKAGE_ROOT, "skills");
-
-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,
-  destDir: string,
-  force: boolean,
-): { copied: number; skipped: number } {
-  let copied = 0;
-  let skipped = 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()) {
-      const sub = copyDirectoryRecursive(srcPath, destPath, force);
-      copied += sub.copied;
-      skipped += sub.skipped;
-    } else {
-      if (!force && fs.existsSync(destPath)) {
-        skipped++;
-        continue;
-      }
-      fs.mkdirSync(destDir, { recursive: true });
-      fs.copyFileSync(srcPath, destPath);
-      copied++;
-    }
-  }
-
-  return { copied, skipped };
-}
-
-export function runInit(cwd: string, force: boolean): number {
+import {
+  copySkills,
+  copyWorkflows,
+  copyConfigs,
+  setupSymlink,
+  isAlreadyInitialized,
+} from "./lib/distribute";
+
+export function runInit(cwd: string): number {
   console.log(chalk.bold("erp-kit init\n"));
 
-  // --- 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;
-  const frameworkSkills = discoverFrameworkSkills();
-  for (const skill of frameworkSkills) {
-    const srcSkillDir = path.join(SKILLS_SRC, skill);
-    if (!fs.existsSync(srcSkillDir)) continue;
-
-    const destDir = path.join(skillsDest, skill);
-    const result = copyDirectoryRecursive(srcSkillDir, destDir, force);
-    copiedCount += result.copied;
-
-    if (result.skipped > 0) {
-      console.log(chalk.yellow(`  Skipped ${skill}/ (${result.skipped} existing files)`));
-      skippedCount += result.skipped;
-    }
-  }
-  console.log(chalk.green(`  Copied ${copiedCount} skill files to .agents/skills/`));
-  if (skippedCount > 0) {
+  if (isAlreadyInitialized(cwd)) {
     console.log(
-      chalk.yellow(`  Skipped ${skippedCount} existing files (use --force to overwrite)`),
+      chalk.yellow("Already initialized. Use `erp-kit update` to refresh framework resources."),
     );
+    return 1;
   }
 
-  // --- Claude Code symlink ---
-  const claudeSkills = path.join(cwd, ".claude", "skills");
-  const relTarget = path.relative(path.dirname(claudeSkills), skillsDest);
+  const skills = copySkills(cwd);
+  console.log(chalk.green(`  Copied ${skills.copied} skill files to .agents/skills/`));
 
-  // lstatSync doesn't follow symlinks, so dangling symlinks are detected
-  const claudeSkillsExists = (() => {
-    try {
-      fs.lstatSync(claudeSkills);
-      return true;
-    } catch {
-      return false;
-    }
-  })();
-
-  if (claudeSkillsExists) {
-    const stat = fs.lstatSync(claudeSkills);
-    if (stat.isSymbolicLink()) {
-      const current = fs.readlinkSync(claudeSkills);
-      if (current === relTarget) {
-        console.log(chalk.green("  .claude/skills -> .agents/skills/ (already linked)"));
-      } else if (force) {
-        fs.unlinkSync(claudeSkills);
-        fs.symlinkSync(relTarget, claudeSkills);
-        console.log(chalk.green("  .claude/skills -> .agents/skills/ (relinked)"));
-      } else {
-        console.log(
-          chalk.yellow(`  Skipped .claude/skills (symlink exists -> ${current}, use --force)`),
-        );
-      }
-    } else {
-      console.log(chalk.yellow("  Skipped .claude/skills (directory exists, not a symlink)"));
-    }
-  } else {
-    fs.mkdirSync(path.dirname(claudeSkills), { recursive: true });
-    fs.symlinkSync(relTarget, claudeSkills);
+  const symlink = setupSymlink(cwd);
+  if (symlink === "linked") {
     console.log(chalk.green("  .claude/skills -> .agents/skills/ (linked)"));
+  } else if (symlink === "skipped_directory") {
+    console.log(chalk.yellow("  Skipped .claude/skills (directory exists, not a symlink)"));
+  }
+
+  const workflows = copyWorkflows(cwd);
+  if (workflows.copied > 0) {
+    console.log(chalk.green(`  Copied ${workflows.copied} workflow(s) to .github/workflows/`));
+  }
+
+  const configs = copyConfigs(cwd);
+  if (configs.copied > 0) {
+    console.log(chalk.green(`  Copied ${configs.copied} config file(s)`));
   }
 
   console.log(chalk.bold.green("\nDone! Run `erp-kit check` to validate your docs."));