@tailor-platform/erp-kit 0.2.2 → 0.4.0

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

@@ -2,384 +2,26 @@ 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, checkStaleness } from "./sync-check";
-import { parseTestCasesFromDoc, parseItDescriptionsFromTest } from "./parse-doc-test-cases";
+import { runSyncCheck } from "./sync-check";
 
-describe("runSyncCheck", () => {
+describe("runSyncCheck (integration)", () => {
   let tmpDir: string;
 
   beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sync-check-"));
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sync-check-int-"));
   });
 
   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("reports missing doc for query source without doc", async () => {
-    const srcDir = path.join(tmpDir, "modules", "foo", "query");
-    fs.mkdirSync(srcDir, { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "convertAmount.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",
-        category: "query",
-        expectedBasename: "convertamount",
-      }),
-    );
-  });
-
-  it("returns 0 when query source and doc match", async () => {
-    const srcDir = path.join(tmpDir, "modules", "foo", "query");
-    const docDir = path.join(tmpDir, "modules", "foo", "docs", "queries");
-    fs.mkdirSync(srcDir, { recursive: true });
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "convertAmount.ts"), "export {}");
-    fs.writeFileSync(path.join(docDir, "convertAmount.md"), "# ConvertAmount");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(0);
-  });
-
-  it("matches generated query files to docs by stripping .generated suffix", async () => {
-    const srcDir = path.join(tmpDir, "modules", "foo", "query");
-    const docDir = path.join(tmpDir, "modules", "foo", "docs", "queries");
-    fs.mkdirSync(srcDir, { recursive: true });
-    fs.mkdirSync(docDir, { recursive: true });
-    fs.writeFileSync(path.join(srcDir, "getCurrency.generated.ts"), "export {}");
-    fs.writeFileSync(path.join(docDir, "GetCurrency.md"), "# GetCurrency");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(0);
-    expect(result.errors).toHaveLength(0);
-  });
-
-  it("excludes generated command files from source matching", async () => {
+  it("combines source sync and test case sync errors", 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(srcDir, "createOrder.generated.ts"), "export {}");
-    fs.writeFileSync(path.join(docDir, "createOrder.md"), "# CreateOrder");
-
-    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
-    expect(result.exitCode).toBe(0);
-  });
-
-  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);
-  });
-});
-
-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(
-      [{ docPath: "docs/commands/CreateItem.md", docMtime: 2000 }],
-      [{ genPath: "lib/errors.generated.ts", genMtime: 1000 }],
-    );
-
-    expect(errors).toHaveLength(1);
-    expect(errors[0].type).toBe("stale-generation");
-  });
-
-  it("reports no staleness when generated is newer", () => {
-    const errors = checkStaleness(
-      [{ docPath: "docs/commands/CreateItem.md", docMtime: 1000 }],
-      [{ genPath: "lib/errors.generated.ts", genMtime: 2000 }],
-    );
-
-    expect(errors).toHaveLength(0);
-  });
-
-  it("returns empty when no generated files", () => {
-    const errors = checkStaleness([{ docPath: "docs/commands/CreateItem.md", docMtime: 1000 }], []);
-
-    expect(errors).toHaveLength(0);
-  });
-
-  it("returns empty when no doc files", () => {
-    const errors = checkStaleness([], [{ genPath: "lib/errors.generated.ts", genMtime: 1000 }]);
-
-    expect(errors).toHaveLength(0);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors.some((e) => e.type === "missing-doc")).toBe(true);
   });
 });

package/src/commands/sync-check.ts

@@ -1,264 +1,20 @@
-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";
+import { runSourceSyncCheck, type SyncCheckResult, type CheckError } from "./lib/sync-check-source";
+import { runTestCaseSyncCheck } from "./lib/sync-check-tests";
 
-interface CategoryConfig {
-  name: string;
-  sourcePattern: string;
-  docPattern: string;
-  exclusions: RegExp[];
-}
-
-export interface CheckError {
-  type: "missing-doc" | "orphaned-doc" | "missing-test-case" | "extra-test-case";
-  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$/, /\.generated\.ts$/],
-    },
-    {
-      name: "model",
-      sourcePattern: `${root}/*/db/*.ts`,
-      docPattern: `${root}/*/docs/models/*.md`,
-      exclusions: [/\.test\.ts$/, /^index\.ts$/],
-    },
-    {
-      name: "query",
-      sourcePattern: `${root}/*/query/*.ts`,
-      docPattern: `${root}/*/docs/queries/*.md`,
-      exclusions: [/\.test\.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 type { SyncCheckResult, CheckError } from "./lib/sync-check-source";
 
 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;
-      let basename = path.basename(sourcePath, path.extname(sourcePath));
-      if (basename.endsWith(".generated")) {
-        basename = basename.slice(0, -".generated".length);
-      }
-      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;
-  }
-
+  const sourceResult = await runSourceSyncCheck(config, cwd);
   if (config.modulesRoot) {
     const testCaseErrors = await runTestCaseSyncCheck(config.modulesRoot, cwd);
-    errors.push(...testCaseErrors);
+    sourceResult.errors.push(...testCaseErrors);
+    sourceResult.exitCode = sourceResult.errors.length > 0 ? 1 : 0;
   }
-
-  return {
-    exitCode: errors.length > 0 ? 1 : 0,
-    errors,
-    summary: {
-      categoriesChecked: allCategories.length,
-      totalSources,
-      totalDocs,
-    },
-  };
-}
-
-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;
-  genPath: string;
-}
-
-export function checkStaleness(
-  docs: { docPath: string; docMtime: number }[],
-  generated: { genPath: string; genMtime: number }[],
-): StalenessError[] {
-  const errors: StalenessError[] = [];
-
-  if (generated.length === 0 || docs.length === 0) return errors;
-
-  const latestDocMtime = Math.max(...docs.map((d) => d.docMtime));
-  const oldestGenMtime = Math.min(...generated.map((g) => g.genMtime));
-
-  if (latestDocMtime > oldestGenMtime) {
-    const newestDoc = docs.find((d) => d.docMtime === latestDocMtime)!;
-    const oldestGen = generated.find((g) => g.genMtime === oldestGenMtime)!;
-    errors.push({
-      type: "stale-generation",
-      docPath: newestDoc.docPath,
-      genPath: oldestGen.genPath,
-    });
-  }
-
-  return errors;
+  return sourceResult;
 }
 
 export function formatSyncCheckReport(result: SyncCheckResult): string {