@tailor-platform/erp-kit 0.0.1 → 0.1.1

package/src/commands/mock/validate.ts

@@ -0,0 +1,198 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join, resolve, relative, dirname, basename } from "node:path";
+import chalk from "chalk";
+
+interface ValidationContext {
+  failures: number;
+}
+
+function pass(msg: string) {
+  console.log(chalk.green(`\u2713 ${msg}`));
+}
+
+function fail(ctx: ValidationContext, msg: string) {
+  console.log(chalk.red(`\u2717 ${msg}`));
+  ctx.failures++;
+}
+
+async function subdirs(dir: string): Promise<string[]> {
+  const entries = await readdir(dir);
+  const dirs: string[] = [];
+  for (const entry of entries) {
+    const full = join(dir, entry);
+    const s = await stat(full);
+    if (s.isDirectory()) dirs.push(entry);
+  }
+  return dirs.sort();
+}
+
+function checkStructure(ctx: ValidationContext, entries: string[], label: string): boolean {
+  if (entries.includes("README.md")) {
+    pass(`${label}: has README.md`);
+  } else {
+    fail(ctx, `${label}: missing README.md`);
+  }
+
+  if (entries.includes("mock.json")) {
+    pass(`${label}: has mock.json`);
+    return true;
+  }
+  fail(ctx, `${label}: missing mock.json`);
+  return false;
+}
+
+async function checkSchema(ctx: ValidationContext, data: MockoonData, label: string) {
+  const commons = await import("@mockoon/commons");
+  // EnvironmentSchemaNoFix is a Joi schema typed as `any` in @mockoon/commons
+  const schema = commons.EnvironmentSchemaNoFix as {
+    validate: (
+      value: unknown,
+      options?: { abortEarly?: boolean },
+    ) => { error?: { details: { message: string }[] } };
+  };
+  const result = schema.validate(data, { abortEarly: false });
+  if (!result.error) {
+    pass(`${label}: valid Mockoon schema`);
+  } else {
+    for (const detail of result.error.details) {
+      fail(ctx, `${label}: schema — ${detail.message}`);
+    }
+  }
+}
+
+interface MockoonRoute {
+  uuid: string;
+  responses?: MockoonResponse[];
+}
+
+interface MockoonResponse {
+  uuid: string;
+  label?: string;
+  headers?: { key: string; value: string }[];
+  bodyType?: string;
+  databucketID?: string;
+}
+
+interface MockoonData {
+  uuid?: string;
+  name?: string;
+  port?: number;
+  routes?: MockoonRoute[];
+  data?: { id: string }[];
+}
+
+function checkResponseQuality(ctx: ValidationContext, data: MockoonData, label: string) {
+  const routes = data.routes ?? [];
+  for (const route of routes) {
+    for (const resp of route.responses ?? []) {
+      const respLabel = `${label} \u2192 ${route.uuid}/${resp.uuid}`;
+      const headers = resp.headers ?? [];
+      const hasContentType = headers.some((h) => h.key.toLowerCase() === "content-type");
+      if (hasContentType) {
+        pass(`${respLabel}: has Content-Type`);
+      } else {
+        fail(ctx, `${respLabel}: missing Content-Type header`);
+      }
+      if (resp.label && resp.label.trim().length > 0) {
+        pass(`${respLabel}: has label "${resp.label}"`);
+      } else {
+        fail(ctx, `${respLabel}: missing or empty label`);
+      }
+    }
+  }
+}
+
+function checkDatabucketRefs(ctx: ValidationContext, data: MockoonData, label: string) {
+  const bucketIds = new Set((data.data ?? []).map((d) => d.id));
+  for (const route of data.routes ?? []) {
+    for (const resp of route.responses ?? []) {
+      if (resp.bodyType === "DATABUCKET") {
+        const respLabel = `${label} \u2192 ${route.uuid}/${resp.uuid}`;
+        if (resp.databucketID && bucketIds.has(resp.databucketID)) {
+          pass(`${respLabel}: databucket "${resp.databucketID}" exists`);
+        } else {
+          fail(ctx, `${respLabel}: databucketID "${resp.databucketID}" not found in data array`);
+        }
+      }
+    }
+  }
+}
+
+async function discoverAllScenarios(mocksDir: string): Promise<string[]> {
+  const scenarios: string[] = [];
+  const providers = await subdirs(mocksDir);
+  for (const provider of providers) {
+    const providerDir = join(mocksDir, provider);
+    for (const scenario of await subdirs(providerDir)) {
+      scenarios.push(`${provider}/${scenario}`);
+    }
+  }
+  return scenarios;
+}
+
+function resolveScenarioDir(arg: string): string {
+  const abs = resolve(arg);
+  if (basename(abs) === "mock.json") return dirname(abs);
+  return abs;
+}
+
+async function validateScenario(ctx: ValidationContext, scenarioDir: string, mocksDir: string) {
+  const label = relative(mocksDir, scenarioDir);
+  console.log(chalk.bold(`\n\u2500\u2500 ${label} \u2500\u2500`));
+
+  let entries: string[];
+  try {
+    entries = await readdir(scenarioDir);
+  } catch {
+    fail(ctx, `${label}: directory not found`);
+    return;
+  }
+
+  const hasMock = checkStructure(ctx, entries, label);
+  if (!hasMock) return;
+
+  const mockPath = join(scenarioDir, "mock.json");
+
+  let data: MockoonData;
+  try {
+    data = JSON.parse(await readFile(mockPath, "utf-8")) as MockoonData;
+  } catch (err: unknown) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    fail(ctx, `${label}: invalid JSON \u2014 ${errMsg}`);
+    return;
+  }
+
+  await checkSchema(ctx, data, label);
+  checkResponseQuality(ctx, data, label);
+  checkDatabucketRefs(ctx, data, label);
+}
+
+export async function runMockValidate(mocksRoot: string, paths: string[]): Promise<number> {
+  const ctx: ValidationContext = { failures: 0 };
+  const mocksDir = resolve(mocksRoot);
+
+  const targets =
+    paths.length > 0
+      ? paths.map(resolveScenarioDir)
+      : (await discoverAllScenarios(mocksDir)).map((s) => join(mocksDir, s));
+
+  if (targets.length === 0) {
+    fail(ctx, "No scenarios found under mocks/");
+    return 1;
+  }
+
+  console.log(chalk.bold("\nValidating mock configs...\n"));
+
+  for (const target of targets) {
+    await validateScenario(ctx, target, mocksDir);
+  }
+
+  console.log(chalk.bold("\n\u2500\u2500 summary \u2500\u2500"));
+  if (ctx.failures === 0) {
+    console.log(chalk.green("\u2713 All checks passed"));
+  } else {
+    console.log(chalk.red(`\u2717 ${ctx.failures} check(s) failed`));
+  }
+
+  return ctx.failures === 0 ? 0 : 1;
+}

package/src/commands/scaffold.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from "vitest";
+import { resolveScaffoldPath } from "./scaffold.js";
+
+describe("resolveScaffoldPath", () => {
+  // Module types
+  it("resolves module scaffold path", () => {
+    const result = resolveScaffoldPath("module", "inventory", undefined, "modules");
+    expect(result).toBe("modules/inventory/README.md");
+  });
+
+  it("resolves command scaffold path", () => {
+    const result = resolveScaffoldPath("command", "inventory", "CreateOrder", "modules");
+    expect(result).toBe("modules/inventory/docs/commands/CreateOrder.md");
+  });
+
+  it("resolves feature scaffold path", () => {
+    const result = resolveScaffoldPath("feature", "inventory", "stock-tracking", "modules");
+    expect(result).toBe("modules/inventory/docs/features/stock-tracking.md");
+  });
+
+  it("resolves model scaffold path", () => {
+    const result = resolveScaffoldPath("model", "inventory", "StockItem", "modules");
+    expect(result).toBe("modules/inventory/docs/models/StockItem.md");
+  });
+
+  // App-compose types
+  it("resolves requirements scaffold path", () => {
+    const result = resolveScaffoldPath("requirements", "my-app", undefined, "examples");
+    expect(result).toBe("examples/my-app/README.md");
+  });
+
+  it("resolves actors scaffold path", () => {
+    const result = resolveScaffoldPath("actors", "my-app", "admin", "examples");
+    expect(result).toBe("examples/my-app/docs/actors/admin.md");
+  });
+
+  it("resolves business-flow scaffold path", () => {
+    const result = resolveScaffoldPath("business-flow", "my-app", "onboarding", "examples");
+    expect(result).toBe("examples/my-app/docs/business-flow/onboarding/README.md");
+  });
+
+  it("resolves story scaffold path with flow/name format", () => {
+    const result = resolveScaffoldPath(
+      "story",
+      "my-app",
+      "onboarding/admin--create-user",
+      "examples",
+    );
+    expect(result).toBe(
+      "examples/my-app/docs/business-flow/onboarding/story/admin--create-user.md",
+    );
+  });
+
+  it("resolves screen scaffold path", () => {
+    const result = resolveScaffoldPath("screen", "my-app", "supplier-list", "examples");
+    expect(result).toBe("examples/my-app/docs/screen/supplier-list.md");
+  });
+
+  it("resolves resolver scaffold path", () => {
+    const result = resolveScaffoldPath("resolver", "my-app", "create-supplier", "examples");
+    expect(result).toBe("examples/my-app/docs/resolver/create-supplier.md");
+  });
+
+  // Validation
+  it("throws when name is required but missing", () => {
+    expect(() => resolveScaffoldPath("command", "inventory", undefined, "modules")).toThrow(
+      "Name is required",
+    );
+  });
+
+  it("throws when story name is not flow/name format", () => {
+    expect(() => resolveScaffoldPath("story", "my-app", "bad-name", "examples")).toThrow(
+      "Story name must be",
+    );
+  });
+});

package/src/commands/scaffold.ts

@@ -0,0 +1,119 @@
+import path from "node:path";
+import fs from "node:fs";
+import { runMdschema } from "../mdschema.js";
+import { ALL_SCHEMAS } from "../schemas.js";
+
+export const MODULE_TYPES = ["module", "feature", "command", "model"] as const;
+export const APP_TYPES = [
+  "requirements",
+  "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];
+
+const MODULE_DIR_MAP: Record<string, string> = {
+  feature: "docs/features",
+  command: "docs/commands",
+  model: "docs/models",
+};
+
+const APP_DIR_MAP: Record<string, string> = {
+  actors: "docs/actors",
+  "business-flow": "docs/business-flow",
+  screen: "docs/screen",
+  resolver: "docs/resolver",
+};
+
+export function isModuleType(type: string): boolean {
+  return (MODULE_TYPES as readonly string[]).includes(type);
+}
+
+export function resolveScaffoldPath(
+  type: ScaffoldType,
+  parentName: string,
+  name: string | undefined,
+  root: string,
+): string {
+  // Types that map to README.md (no name needed)
+  if (type === "module" || type === "requirements") {
+    return path.join(root, parentName, "README.md");
+  }
+
+  if (!name) {
+    throw new Error(`Name is required for scaffold type "${type}"`);
+  }
+
+  // business-flow produces a README inside a named directory
+  if (type === "business-flow") {
+    return path.join(root, parentName, "docs/business-flow", name, "README.md");
+  }
+
+  // story accepts "flow/story-name" to place under the correct flow directory
+  if (type === "story") {
+    const parts = name.split("/");
+    if (parts.length !== 2) {
+      throw new Error(
+        `Story name must be "<flow>/<story>" (e.g., "onboarding/admin--create-user")`,
+      );
+    }
+    return path.join(root, parentName, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
+  }
+
+  // Module sub-types
+  if (MODULE_DIR_MAP[type]) {
+    return path.join(root, parentName, MODULE_DIR_MAP[type], `${name}.md`);
+  }
+
+  // App sub-types
+  if (APP_DIR_MAP[type]) {
+    return path.join(root, parentName, APP_DIR_MAP[type], `${name}.md`);
+  }
+
+  throw new Error(`Unknown scaffold type: ${type}`);
+}
+
+export async function runScaffold(
+  type: ScaffoldType,
+  parentName: string,
+  name: string | undefined,
+  root: string,
+  cwd: string,
+): Promise<number> {
+  const outputPath = resolveScaffoldPath(type, parentName, name, root);
+  const absoluteOutput = path.resolve(cwd, outputPath);
+
+  if (fs.existsSync(absoluteOutput)) {
+    console.error(`File already exists: ${outputPath}`);
+    return 1;
+  }
+
+  const schemaPath = ALL_SCHEMAS[type];
+  if (!schemaPath) {
+    console.error(`No schema found for type: ${type}`);
+    return 2;
+  }
+
+  try {
+    fs.mkdirSync(path.dirname(absoluteOutput), { recursive: true });
+  } catch (err) {
+    console.error(
+      `Failed to create directory: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return 1;
+  }
+
+  const { exitCode, stdout, stderr } = await runMdschema(
+    ["generate", "--schema", schemaPath, "--output", absoluteOutput],
+    cwd,
+  );
+
+  if (stdout.trim()) console.log(stdout);
+  if (stderr.trim()) console.error(stderr);
+
+  return exitCode;
+}

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

@@ -0,0 +1,125 @@
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { runSyncCheck } from "./sync-check.js";
+
+describe("runSyncCheck", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sync-check-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns 0 for an empty directory with no sources or docs", async () => {
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("reports missing doc when source exists without doc", async () => {
+    const srcDir = path.join(tmpDir, "modules", "foo", "command");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "createOrder.ts"), "export {}");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors).toContainEqual(
+      expect.objectContaining({ type: "missing-doc", expectedBasename: "createorder" }),
+    );
+  });
+
+  it("reports orphaned doc when doc exists without source", async () => {
+    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.writeFileSync(path.join(docDir, "createOrder.md"), "# CreateOrder");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors).toContainEqual(
+      expect.objectContaining({ type: "orphaned-doc", expectedBasename: "createorder" }),
+    );
+  });
+
+  it("returns 0 when source and doc match", async () => {
+    const srcDir = path.join(tmpDir, "modules", "foo", "command");
+    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "createOrder.ts"), "export {}");
+    fs.writeFileSync(path.join(docDir, "createOrder.md"), "# CreateOrder");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("excludes test files from source matching", async () => {
+    const srcDir = path.join(tmpDir, "modules", "foo", "command");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "createOrder.test.ts"), "test()");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("uses custom modulesRoot to rewrite glob patterns", async () => {
+    const srcDir = path.join(tmpDir, "custom-mods", "foo", "command");
+    const docDir = path.join(tmpDir, "custom-mods", "foo", "docs", "commands");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "createOrder.ts"), "export {}");
+    fs.writeFileSync(path.join(docDir, "createOrder.md"), "# CreateOrder");
+
+    const result = await runSyncCheck({ modulesRoot: "custom-mods" }, tmpDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.summary.totalSources).toBe(1);
+  });
+
+  it("uses custom appRoot to rewrite glob patterns", async () => {
+    const srcDir = path.join(
+      tmpDir,
+      "apps",
+      "app1",
+      "backend",
+      "src",
+      "modules",
+      "m1",
+      "resolvers",
+    );
+    const docDir = path.join(tmpDir, "apps", "app1", "docs", "resolver");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "myResolver.ts"), "export {}");
+    fs.writeFileSync(path.join(docDir, "myResolver.md"), "# MyResolver");
+
+    const result = await runSyncCheck({ appRoot: "apps" }, tmpDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.summary.totalSources).toBe(1);
+  });
+
+  it("checks only module patterns when appRoot is not set", async () => {
+    const resolverSrcDir = path.join(
+      tmpDir,
+      "examples",
+      "app1",
+      "backend",
+      "src",
+      "modules",
+      "m1",
+      "resolvers",
+    );
+    fs.mkdirSync(resolverSrcDir, { recursive: true });
+    fs.writeFileSync(path.join(resolverSrcDir, "myResolver.ts"), "export {}");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: undefined }, tmpDir);
+    // Without appRoot, app-compose patterns are not checked
+    expect(result.exitCode).toBe(0);
+    expect(result.errors).toHaveLength(0);
+  });
+});

package/src/commands/sync-check.ts

@@ -0,0 +1,182 @@
+import path from "node:path";
+import fg from "fast-glob";
+import chalk from "chalk";
+
+interface CategoryConfig {
+  name: string;
+  sourcePattern: string;
+  docPattern: string;
+  exclusions: RegExp[];
+}
+
+export interface CheckError {
+  type: "missing-doc" | "orphaned-doc";
+  category: string;
+  sourcePath?: string;
+  docPath?: string;
+  expectedBasename: string;
+}
+
+export interface SyncCheckResult {
+  exitCode: number;
+  errors: CheckError[];
+  summary: {
+    categoriesChecked: number;
+    totalSources: number;
+    totalDocs: number;
+  };
+}
+
+function moduleCategories(root: string): CategoryConfig[] {
+  return [
+    {
+      name: "command",
+      sourcePattern: `${root}/*/command/*.ts`,
+      docPattern: `${root}/*/docs/commands/*.md`,
+      exclusions: [/\.test\.ts$/],
+    },
+    {
+      name: "model",
+      sourcePattern: `${root}/*/db/*.ts`,
+      docPattern: `${root}/*/docs/models/*.md`,
+      exclusions: [/\.test\.ts$/, /^index\.ts$/],
+    },
+  ];
+}
+
+function appComposeCategories(root: string): CategoryConfig[] {
+  return [
+    {
+      name: "resolver",
+      sourcePattern: `${root}/*/backend/src/modules/**/resolvers/*.ts`,
+      docPattern: `${root}/*/docs/resolver/*.md`,
+      exclusions: [/\.test\.ts$/, /^index\.ts$/],
+    },
+  ];
+}
+
+function shouldExclude(fileName: string, exclusions: RegExp[]): boolean {
+  return exclusions.some((pattern) => pattern.test(fileName));
+}
+
+export async function runSyncCheck(
+  config: { modulesRoot?: string; appRoot?: string },
+  cwd: string,
+): Promise<SyncCheckResult> {
+  const errors: CheckError[] = [];
+  let totalSources = 0;
+  let totalDocs = 0;
+
+  const allCategories: CategoryConfig[] = [];
+  if (config.modulesRoot) {
+    allCategories.push(...moduleCategories(config.modulesRoot));
+  }
+  if (config.appRoot) {
+    allCategories.push(...appComposeCategories(config.appRoot));
+  }
+
+  for (const category of allCategories) {
+    const sources = await fg(category.sourcePattern, { cwd });
+    const docs = await fg(category.docPattern, { cwd });
+
+    const sourceBasenames = new Map<string, string>();
+    const docBasenames = new Map<string, string>();
+
+    for (const sourcePath of sources) {
+      const fileName = path.basename(sourcePath);
+      if (shouldExclude(fileName, category.exclusions)) continue;
+      const basename = path.basename(sourcePath, path.extname(sourcePath));
+      sourceBasenames.set(basename.toLowerCase(), sourcePath);
+    }
+
+    for (const docPath of docs) {
+      const basename = path.basename(docPath, path.extname(docPath));
+      docBasenames.set(basename.toLowerCase(), docPath);
+    }
+
+    for (const [basename, sourcePath] of sourceBasenames) {
+      if (!docBasenames.has(basename)) {
+        errors.push({
+          type: "missing-doc",
+          category: category.name,
+          sourcePath,
+          expectedBasename: basename,
+        });
+      }
+    }
+
+    for (const [basename, docPath] of docBasenames) {
+      if (!sourceBasenames.has(basename)) {
+        errors.push({
+          type: "orphaned-doc",
+          category: category.name,
+          docPath,
+          expectedBasename: basename,
+        });
+      }
+    }
+
+    totalSources += sourceBasenames.size;
+    totalDocs += docBasenames.size;
+  }
+
+  return {
+    exitCode: errors.length > 0 ? 1 : 0,
+    errors,
+    summary: {
+      categoriesChecked: allCategories.length,
+      totalSources,
+      totalDocs,
+    },
+  };
+}
+
+export function formatSyncCheckReport(result: SyncCheckResult): string {
+  const lines: string[] = [];
+  lines.push(chalk.bold("docs-sync-check: Checking source-documentation correspondence...\n"));
+
+  if (result.errors.length > 0) {
+    lines.push(chalk.red.bold("Errors:\n"));
+    const byCategory = new Map<string, CheckError[]>();
+    for (const error of result.errors) {
+      const existing = byCategory.get(error.category) ?? [];
+      existing.push(error);
+      byCategory.set(error.category, existing);
+    }
+    for (const [category, categoryErrors] of byCategory) {
+      lines.push(chalk.cyan(`  Category: ${category}\n`));
+      for (const error of categoryErrors) {
+        if (error.type === "missing-doc") {
+          lines.push(`  ${chalk.red(error.sourcePath)}`);
+          lines.push(`    ${chalk.yellow("Missing documentation for:")} ${error.expectedBasename}`);
+        } else {
+          lines.push(`  ${chalk.red(error.docPath)}`);
+          lines.push(
+            `    ${chalk.yellow("Orphaned documentation:")} no source file for ${error.expectedBasename}`,
+          );
+        }
+        lines.push("");
+      }
+    }
+  } else {
+    lines.push(chalk.green("All source files have corresponding documentation.\n"));
+  }
+
+  lines.push(chalk.bold("Summary:"));
+  lines.push(`  Categories checked: ${result.summary.categoriesChecked}`);
+  lines.push(
+    `  Source files: ${result.summary.totalSources}, Doc files: ${result.summary.totalDocs}`,
+  );
+
+  if (result.errors.length > 0) {
+    lines.push(chalk.red(`  Errors: ${result.errors.length}`));
+    lines.push("");
+    lines.push(chalk.red.bold(`docs-sync-check failed with ${result.errors.length} error(s).`));
+  } else {
+    lines.push(chalk.green("  Errors: 0"));
+    lines.push("");
+    lines.push(chalk.green.bold("docs-sync-check passed."));
+  }
+
+  return lines.join("\n");
+}