@aigne/doc-smith 0.8.12-beta.8 → 0.8.12-beta.9

package/tests/agents/utils/load-sources.test.mjs

@@ -1,1470 +0,0 @@
-import { afterAll, afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import path, { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import loadSources from "../../../agents/utils/load-sources.mjs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-describe("load-sources", () => {
-  let testDir;
-  let tempDir;
-
-  beforeEach(async () => {
-    // Create test directory structure with unique name to avoid conflicts
-    const uniqueId = `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-    testDir = path.join(__dirname, `test-content-generator-${uniqueId}`);
-    tempDir = path.join(testDir, "temp");
-
-    await mkdir(testDir, { recursive: true });
-    await mkdir(tempDir, { recursive: true });
-    await mkdir(path.join(testDir, "src"), { recursive: true });
-    await mkdir(path.join(testDir, "docs"), { recursive: true });
-    await mkdir(path.join(testDir, "node_modules"), { recursive: true });
-    await mkdir(path.join(testDir, "test"), { recursive: true });
-
-    // Create multi-level directory structure under src
-    await mkdir(path.join(testDir, "src/components"), { recursive: true });
-    await mkdir(path.join(testDir, "src/components/ui"), { recursive: true });
-    await mkdir(path.join(testDir, "src/utils/helpers"), { recursive: true });
-    await mkdir(path.join(testDir, "src/services/api"), { recursive: true });
-    await mkdir(path.join(testDir, "src/config"), { recursive: true });
-
-    // Create test files in root and src
-    await writeFile(path.join(testDir, "package.json"), JSON.stringify({ name: "test" }));
-    await writeFile(path.join(testDir, "README.md"), "# Test Project");
-    await writeFile(path.join(testDir, "src/index.js"), "console.log('hello');");
-    await writeFile(path.join(testDir, "src/utils.js"), "export function test() {}");
-
-    // Create files in multi-level directories
-    await writeFile(path.join(testDir, "src/components/Button.js"), "export class Button {}");
-    await writeFile(path.join(testDir, "src/components/ui/Modal.js"), "export class Modal {}");
-    await writeFile(path.join(testDir, "src/components/ui/Input.js"), "export class Input {}");
-    await writeFile(
-      path.join(testDir, "src/utils/helpers/format.js"),
-      "export function format() {}",
-    );
-    await writeFile(
-      path.join(testDir, "src/utils/helpers/validate.js"),
-      "export function validate() {}",
-    );
-    await writeFile(path.join(testDir, "src/services/api/client.js"), "export class ApiClient {}");
-    await writeFile(
-      path.join(testDir, "src/services/api/endpoints.js"),
-      "export const endpoints = {}",
-    );
-    await writeFile(path.join(testDir, "src/config/database.js"), "export const dbConfig = {}");
-    await writeFile(path.join(testDir, "src/config/app.js"), "export const appConfig = {}");
-
-    // Create some non-JS files to test filtering
-    await writeFile(path.join(testDir, "src/components/ui/styles.css"), "/* styles */");
-    await writeFile(
-      path.join(testDir, "src/config/settings.json"),
-      JSON.stringify({ theme: "dark" }),
-    );
-    await writeFile(path.join(testDir, "src/utils/helpers/data.yaml"), "version: 1.0");
-
-    // Create test files
-    await writeFile(path.join(testDir, "test/test.js"), "describe('test', () => {});");
-
-    // Create files with _test pattern to test the new exclusion
-    await writeFile(path.join(testDir, "src/server_test.go"), "func TestServer() {}");
-    await writeFile(path.join(testDir, "src/user_test.js"), "describe('user', () => {});");
-    await writeFile(path.join(testDir, "src/api_test.ts"), "describe('api', () => {});");
-    await writeFile(path.join(testDir, "src/utils_test.py"), "def test_utils(): pass");
-    await writeFile(
-      path.join(testDir, "src/components/Button_test.jsx"),
-      "test('button', () => {});",
-    );
-    await writeFile(
-      path.join(testDir, "src/utils/helpers/format_test.js"),
-      "test('format', () => {});",
-    );
-
-    await mkdir(path.join(testDir, "node_modules/some-package"), {
-      recursive: true,
-    });
-    await writeFile(path.join(testDir, "node_modules/some-package/package.json"), "{}");
-    await writeFile(path.join(testDir, "temp/temp.txt"), "temp file");
-    await writeFile(path.join(testDir, "ignore.txt"), "should be ignored");
-
-    // Create .gitignore file
-    await writeFile(
-      path.join(testDir, ".gitignore"),
-      "node_modules/\n" + "temp/\n" + "ignore.txt\n" + "*.log\n",
-    );
-  });
-
-  afterEach(async () => {
-    // Clean up test directory with comprehensive handling
-    try {
-      await rm(testDir, { recursive: true, force: true });
-    } catch {
-      // Try multiple cleanup strategies
-      try {
-        const { chmod, readdir, unlink } = await import("node:fs/promises");
-
-        // Reset permissions recursively
-        const resetPermissions = async (dir) => {
-          try {
-            await chmod(dir, 0o755);
-            const entries = await readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-              const fullPath = path.join(dir, entry.name);
-              if (entry.isDirectory()) {
-                await resetPermissions(fullPath);
-              } else {
-                try {
-                  await chmod(fullPath, 0o644);
-                } catch {
-                  // Try to remove symbolic links directly
-                  try {
-                    await unlink(fullPath);
-                  } catch {
-                    // Ignore individual file cleanup failures
-                  }
-                }
-              }
-            }
-          } catch {
-            // Ignore permission reset failures
-          }
-        };
-
-        await resetPermissions(testDir);
-        await rm(testDir, { recursive: true, force: true });
-      } catch {
-        // Final fallback - try to remove with system command
-        try {
-          const { exec } = await import("node:child_process");
-          const { promisify } = await import("node:util");
-          const execAsync = promisify(exec);
-          await execAsync(`rm -rf "${testDir}"`);
-        } catch {
-          // Ignore final cleanup failures - test isolation is more important than perfect cleanup
-          console.warn(`Warning: Could not fully clean up test directory: ${testDir}`);
-        }
-      }
-    }
-  });
-
-  test("should load files with default patterns", async () => {
-    const result = await loadSources({
-      sourcesPath: testDir,
-      useDefaultPatterns: true,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-    expect(result.files.length).toBeGreaterThan(0);
-
-    // Should include package.json, README.md, src files
-    const filePaths = result.files;
-    expect(filePaths.some((element) => element.includes("package.json"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("README.md"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-
-    // Should exclude node_modules, temp, test files
-    expect(filePaths.some((element) => element.includes("node_modules"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("temp/"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("test/test.js"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("ignore.txt"))).toBe(false);
-  });
-
-  test("should load files with custom patterns", async () => {
-    const result = await loadSources({
-      sourcesPath: testDir,
-      includePatterns: ["*.js", "*.json"],
-      excludePatterns: ["test/*"],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-    expect(result.files.length).toBeGreaterThan(0);
-
-    const filePaths = result.files;
-    expect(filePaths.some((element) => element.includes("package.json"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils.js"))).toBe(true);
-
-    // Should exclude test files
-    expect(filePaths.some((element) => element.includes("test/test.js"))).toBe(false);
-  });
-
-  test("should respect .gitignore patterns", async () => {
-    const result = await loadSources({
-      sourcesPath: testDir,
-      includePatterns: ["*"],
-      excludePatterns: [],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-
-    const filePaths = result.files;
-
-    // Should exclude files listed in .gitignore
-    expect(filePaths.some((element) => element.includes("node_modules"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("temp/"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("ignore.txt"))).toBe(false);
-  });
-
-  test("should handle path-based patterns", async () => {
-    const result = await loadSources({
-      sourcesPath: testDir,
-      includePatterns: ["src/**/*.js"],
-      excludePatterns: ["**/test/**"],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-
-    const filePaths = result.files;
-    expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils.js"))).toBe(true);
-
-    // Should exclude test files
-    expect(filePaths.some((element) => element.includes("test/test.js"))).toBe(false);
-  });
-
-  test("should handle multiple source paths", async () => {
-    const result = await loadSources({
-      sourcesPath: [testDir, path.join(testDir, "src")],
-      includePatterns: ["*.js"],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-    expect(result.files.length).toBeGreaterThan(0);
-
-    const filePaths = result.files;
-    expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils.js"))).toBe(true);
-  });
-
-  test("should handle non-existent directories gracefully", async () => {
-    const result = await loadSources({
-      sourcesPath: path.join(testDir, "non-existent"),
-      useDefaultPatterns: true,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-    expect(result.files.length).toBe(0);
-  });
-
-  test("should merge user patterns with default patterns", async () => {
-    const result = await loadSources({
-      sourcesPath: testDir,
-      includePatterns: ["*.txt"],
-      excludePatterns: ["docs/*"],
-      useDefaultPatterns: true,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-
-    const filePaths = result.files;
-
-    // Should include default patterns (package.json, README.md, etc.)
-    expect(filePaths.some((element) => element.includes("package.json"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("README.md"))).toBe(true);
-
-    // Should exclude user exclude patterns
-    expect(filePaths.some((element) => element.includes("docs/"))).toBe(false);
-  });
-
-  test("should handle multi-level directory structure", async () => {
-    const result = await loadSources({
-      sourcesPath: testDir,
-      includePatterns: ["**/*.js"],
-      excludePatterns: [],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-    expect(result.files.length).toBeGreaterThan(0);
-
-    const filePaths = result.files;
-
-    // Should include files from all levels
-    expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/components/Button.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/components/ui/Modal.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/components/ui/Input.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils/helpers/format.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils/helpers/validate.js"))).toBe(
-      true,
-    );
-    expect(filePaths.some((element) => element.includes("src/services/api/client.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/services/api/endpoints.js"))).toBe(
-      true,
-    );
-    expect(filePaths.some((element) => element.includes("src/config/database.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/config/app.js"))).toBe(true);
-
-    // Should exclude non-JS files
-    expect(filePaths.some((element) => element.includes("styles.css"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("settings.json"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("data.yaml"))).toBe(false);
-  });
-
-  test("should filter by specific subdirectories", async () => {
-    const result = await loadSources({
-      sourcesPath: testDir,
-      includePatterns: ["src/components/**/*.js", "src/utils/**/*.js"],
-      excludePatterns: ["src/components/ui/*.js"],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-
-    const filePaths = result.files;
-
-    // Should include files from specified subdirectories
-    expect(filePaths.some((element) => element.includes("src/components/Button.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils/helpers/format.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils/helpers/validate.js"))).toBe(
-      true,
-    );
-
-    // Should exclude files from excluded subdirectories
-    expect(filePaths.some((element) => element.includes("src/components/ui/Modal.js"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("src/components/ui/Input.js"))).toBe(false);
-
-    // Should exclude files from other directories
-    expect(filePaths.some((element) => element.includes("src/services/api/client.js"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("src/config/database.js"))).toBe(false);
-  });
-
-  test("should handle mixed file types in multi-level directories", async () => {
-    const result = await loadSources({
-      sourcesPath: testDir,
-      includePatterns: ["**/*.js", "**/*.json", "**/*.yaml"],
-      excludePatterns: ["**/node_modules/**"],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-
-    const filePaths = result.files;
-
-    // Should include JS files from all levels
-    expect(filePaths.some((element) => element.includes("src/components/Button.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils/helpers/format.js"))).toBe(true);
-
-    // Should include JSON and YAML files
-    expect(filePaths.some((element) => element.includes("src/config/settings.json"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils/helpers/data.yaml"))).toBe(true);
-
-    // Should exclude CSS files
-    expect(filePaths.some((element) => element.includes("styles.css"))).toBe(false);
-
-    // Should exclude node_modules
-    expect(filePaths.some((element) => element.includes("node_modules"))).toBe(false);
-  });
-
-  test("should exclude files with _test pattern using default patterns", async () => {
-    const result = await loadSources({
-      sourcesPath: testDir,
-      useDefaultPatterns: true,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-
-    const filePaths = result.files;
-
-    // For now, let's verify that regular files are still included
-    expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/components/Button.js"))).toBe(true);
-
-    // And verify that some expected exclusions are working
-    expect(filePaths.some((element) => element.includes("node_modules"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("temp/"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("test/test.js"))).toBe(false);
-  });
-
-  test("should handle glob patterns in sourcesPath", async () => {
-    const result = await loadSources({
-      sourcesPath: [`${testDir}/src/**/*.js`],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-    expect(result.files.length).toBeGreaterThan(0);
-
-    const filePaths = result.files;
-
-    // Should include JS files from src directory and subdirectories
-    expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/components/Button.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/components/ui/Modal.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils/helpers/format.js"))).toBe(true);
-
-    // Should exclude non-JS files and files outside src
-    expect(filePaths.some((element) => element.includes("package.json"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("README.md"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("styles.css"))).toBe(false);
-  });
-
-  test("should handle multiple glob patterns in sourcesPath", async () => {
-    const result = await loadSources({
-      sourcesPath: [`${testDir}/src/**/*.js`, `${testDir}/*.json`, `${testDir}/*.md`],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-    expect(result.files.length).toBeGreaterThan(0);
-
-    const filePaths = result.files;
-
-    // Should include JS files from src directory
-    expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/components/Button.js"))).toBe(true);
-
-    // Should include JSON files from root
-    expect(filePaths.some((element) => element.includes("package.json"))).toBe(true);
-
-    // Should include Markdown files from root
-    expect(filePaths.some((element) => element.includes("README.md"))).toBe(true);
-
-    // Should exclude CSS files
-    expect(filePaths.some((element) => element.includes("styles.css"))).toBe(false);
-  });
-
-  test("should handle glob pattern with specific file extensions", async () => {
-    const result = await loadSources({
-      sourcesPath: [`${testDir}/src/**/*.{js,json,yaml}`],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-
-    const filePaths = result.files;
-
-    // Should include JS files
-    expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/utils.js"))).toBe(true);
-
-    // Should include JSON files
-    expect(filePaths.some((element) => element.includes("src/config/settings.json"))).toBe(true);
-
-    // Should include YAML files
-    expect(filePaths.some((element) => element.includes("src/utils/helpers/data.yaml"))).toBe(true);
-
-    // Should exclude CSS files
-    expect(filePaths.some((element) => element.includes("styles.css"))).toBe(false);
-  });
-
-  test("should handle glob pattern that matches no files", async () => {
-    const result = await loadSources({
-      sourcesPath: [`${testDir}/nonexistent/**/*.xyz`],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-    expect(result.files.length).toBe(0);
-  });
-
-  test("should handle mixed regular paths and glob patterns", async () => {
-    const result = await loadSources({
-      sourcesPath: [testDir, `${testDir}/src/**/*.js`],
-      includePatterns: ["*.md"],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-    expect(result.files.length).toBeGreaterThan(0);
-
-    const filePaths = result.files;
-
-    // Should include markdown files from directory scan
-    expect(filePaths.some((element) => element.includes("README.md"))).toBe(true);
-
-    // Should include JS files from glob pattern
-    expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-    expect(filePaths.some((element) => element.includes("src/components/Button.js"))).toBe(true);
-  });
-
-  test("should handle glob patterns with wildcards and character classes", async () => {
-    const result = await loadSources({
-      sourcesPath: [`${testDir}/src/**/[Bb]utton.js`, `${testDir}/src/**/?odal.js`],
-      useDefaultPatterns: false,
-      outputDir: tempDir,
-      docsDir: path.join(testDir, "docs"),
-    });
-
-    expect(result.files).toBeDefined();
-
-    const filePaths = result.files;
-
-    // Should match Button.js with character class
-    expect(filePaths.some((element) => element.includes("src/components/Button.js"))).toBe(true);
-
-    // Should match Modal.js with single character wildcard
-    expect(filePaths.some((element) => element.includes("src/components/ui/Modal.js"))).toBe(true);
-
-    // Should not match other files
-    expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(false);
-    expect(filePaths.some((element) => element.includes("src/utils.js"))).toBe(false);
-  });
-
-  describe("Configuration integration tests", () => {
-    test("should handle YAML config-like sourcesPath input", async () => {
-      const yamlConfigInput = {
-        sourcesPath: ["./src", "./lib", "**/*.{js,ts,jsx,tsx}"],
-        docsDir: "./docs",
-        useDefaultPatterns: true,
-        outputDir: tempDir,
-      };
-
-      const result = await loadSources(yamlConfigInput);
-
-      expect(result.files).toBeDefined();
-      expect(result.files.length).toBeGreaterThan(0);
-
-      const filePaths = result.files;
-      expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-    });
-
-    test("should handle config with empty sourcesPath array - ACTUALLY WORKS", async () => {
-      // This test shows that empty arrays are actually handled correctly
-      const result = await loadSources({
-        sourcesPath: [],
-        useDefaultPatterns: true,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      expect(result.files.length).toBe(0);
-      expect(result.files.length).toBe(0);
-
-      // Empty arrays are handled gracefully - this is correct behavior
-    });
-
-    test("should filter invalid path elements gracefully - EXPOSES ROBUSTNESS BUG", async () => {
-      // ROBUSTNESS BUG TEST: Function should handle invalid elements gracefully
-      const mixedArray = ["./src", null, undefined, "./lib", ""];
-
-      // This test expects the function to filter out invalid elements and work with valid ones
-      const result = await loadSources({
-        sourcesPath: mixedArray,
-        useDefaultPatterns: true,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      // Should successfully process valid paths and ignore invalid ones
-      expect(result.files).toBeDefined();
-      // This test will FAIL because the function crashes instead of filtering
-    });
-
-    test("should handle config with undefined sourcesPath - ACTUALLY WORKS", async () => {
-      // This test shows undefined sourcesPath is actually handled correctly
-      const result = await loadSources({
-        sourcesPath: undefined,
-        useDefaultPatterns: true,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      expect(Array.isArray(result.files)).toBe(true);
-      expect(result.files.length).toBe(0);
-
-      // undefined is handled gracefully by skipping sourcesPath processing
-    });
-  });
-
-  describe("Function robustness issues - EXPOSES INPUT HANDLING PROBLEMS", () => {
-    test("should handle invalid inputs gracefully - EXPOSES POOR ERROR HANDLING", async () => {
-      // ROBUSTNESS TEST: Function should validate inputs and provide helpful errors
-      const invalidInputs = [
-        { value: [null], description: "array with null element", shouldFail: true },
-        { value: [undefined], description: "array with undefined element", shouldFail: true },
-        { value: ["", null], description: "mixed array with null", shouldFail: true },
-      ];
-
-      for (const { value: invalidInput, shouldFail } of invalidInputs) {
-        if (shouldFail) {
-          // These should provide helpful error messages, not crash unexpectedly
-          const result = await loadSources({
-            sourcesPath: invalidInput,
-            useDefaultPatterns: true,
-            outputDir: tempDir,
-            docsDir: path.join(testDir, "docs"),
-          });
-          expect(result.files).toBeDefined();
-          expect(Array.isArray(result.files)).toBe(true);
-          expect(result.files.length).toBe(0);
-        }
-      }
-
-      // Test inputs that should work but be handled gracefully
-      const shouldWorkInputs = [
-        null, // Should be treated like undefined
-        "", // Should be treated like undefined
-        123, // Should provide helpful error
-        {}, // Should provide helpful error
-        [""], // Should filter out empty strings
-      ];
-
-      for (const validInput of shouldWorkInputs) {
-        // These tests expect graceful handling but may FAIL due to poor input validation
-        const result = await loadSources({
-          sourcesPath: validInput,
-          useDefaultPatterns: true,
-          outputDir: tempDir,
-          docsDir: path.join(testDir, "docs"),
-        });
-
-        expect(result.files).toBeDefined();
-        // Some of these tests will FAIL, exposing input validation issues
-      }
-    });
-  });
-
-  describe("File system edge cases", () => {
-    test("should handle symbolic links", async () => {
-      // Skip on systems that don't support symlinks
-      try {
-        const { symlink } = await import("node:fs/promises");
-        const symlinkPath = path.join(testDir, "symlink-to-src");
-        await symlink(path.join(testDir, "src"), symlinkPath);
-
-        const result = await loadSources({
-          sourcesPath: symlinkPath,
-          includePatterns: ["*.js"],
-          useDefaultPatterns: false,
-          outputDir: tempDir,
-          docsDir: path.join(testDir, "docs"),
-        });
-
-        expect(result.files).toBeDefined();
-        const filePaths = result.files;
-        expect(filePaths.some((element) => element.includes("index.js"))).toBe(true);
-      } catch {
-        // Skip test on systems that don't support symlinks
-        expect(true).toBe(true);
-      }
-    });
-
-    test("should handle very deep directory structures", async () => {
-      // Create deep nested structure
-      const deepPath = path.join(testDir, "a/b/c/d/e/f/g/h");
-      await mkdir(deepPath, { recursive: true });
-      await writeFile(path.join(deepPath, "deep.js"), "console.log('deep');");
-
-      const content = await readFile(path.join(deepPath, "deep.js"), "utf8");
-      console.log("deep content", content);
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["**/*.js"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      const filePaths = result.files;
-      expect(filePaths.some((element) => element.includes("a/b/c/d/e/f/g/h/deep.js"))).toBe(true);
-    });
-
-    test("should handle files with unusual names", async () => {
-      // Create files with special characters in names
-      await writeFile(path.join(testDir, "file with spaces.js"), "console.log('spaces');");
-      await writeFile(path.join(testDir, "file-with-dashes.js"), "console.log('dashes');");
-      await writeFile(
-        path.join(testDir, "file_with_underscores.js"),
-        "console.log('underscores');",
-      );
-      await writeFile(path.join(testDir, "file.with.dots.js"), "console.log('dots');");
-      await writeFile(path.join(testDir, "文件中文名.js"), "console.log('chinese');");
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["*.js"],
-        excludePatterns: ["**/test/**", "*_test*"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      const filePaths = result.files;
-
-      expect(filePaths.some((element) => element.includes("file with spaces.js"))).toBe(true);
-      expect(filePaths.some((element) => element.includes("file-with-dashes.js"))).toBe(true);
-      expect(filePaths.some((element) => element.includes("file_with_underscores.js"))).toBe(true);
-      expect(filePaths.some((element) => element.includes("file.with.dots.js"))).toBe(true);
-      expect(filePaths.some((element) => element.includes("文件中文名.js"))).toBe(true);
-    });
-
-    test("should handle empty directories", async () => {
-      const emptyDir = path.join(testDir, "empty");
-      await mkdir(emptyDir, { recursive: true });
-
-      const result = await loadSources({
-        sourcesPath: emptyDir,
-        useDefaultPatterns: true,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      expect(result.files.length).toBe(0);
-    });
-  });
-
-  describe("Pattern matching edge cases", () => {
-    test("should handle negation patterns correctly", async () => {
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["**/*.js"],
-        excludePatterns: ["!src/components/**"], // Negation should include
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      const filePaths = result.files;
-
-      // Should still exclude test files by default gitignore/patterns
-      expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(true);
-      expect(filePaths.some((element) => element.includes("src/components/Button.js"))).toBe(true);
-    });
-
-    test("should handle conflicting include/exclude patterns", async () => {
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["src/**/*.js"], // Include all JS in src
-        excludePatterns: ["src/**/*.js"], // But exclude all JS in src
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      const filePaths = result.files;
-
-      // Exclude should win over include
-      expect(filePaths.some((element) => element.includes("src/index.js"))).toBe(false);
-      expect(filePaths.some((element) => element.includes("src/components/Button.js"))).toBe(false);
-    });
-
-    test("should handle case sensitivity in patterns", async () => {
-      // Create files with different cases
-      await writeFile(path.join(testDir, "CamelCase.js"), "console.log('CamelCase');");
-      await writeFile(path.join(testDir, "lowercase.js"), "console.log('lowercase');");
-      await writeFile(path.join(testDir, "UPPERCASE.JS"), "console.log('UPPERCASE');");
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["*.[jJ][sS]"], // Case insensitive for extension
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      const filePaths = result.files;
-
-      expect(filePaths.some((element) => element.includes("CamelCase.js"))).toBe(true);
-      expect(filePaths.some((element) => element.includes("lowercase.js"))).toBe(true);
-      expect(filePaths.some((element) => element.includes("UPPERCASE.JS"))).toBe(true);
-    });
-
-    test("should handle extremely complex glob patterns", async () => {
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: [
-          "src/**/!(test|spec)*{.js,.ts,.jsx,.tsx}", // Complex negation with alternatives
-          "**/@(components|utils|services)/**/*.{js,ts}", // At-patterns with alternatives
-        ],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      // Just verify it doesn't crash and returns some results
-      expect(Array.isArray(result.files)).toBe(true);
-    });
-  });
-
-  describe("Performance and scale tests", () => {
-    test("should handle large number of patterns efficiently", async () => {
-      const manyPatterns = Array(100)
-        .fill(0)
-        .map((_, i) => `**/*${i}*.js`);
-
-      const startTime = Date.now();
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: manyPatterns,
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-      const endTime = Date.now();
-
-      expect(result.files).toBeDefined();
-      expect(endTime - startTime).toBeLessThan(5000); // Should complete within 5 seconds
-    });
-
-    test("should handle very long paths", async () => {
-      const longDirName = "a".repeat(100);
-      const longPath = path.join(testDir, longDirName);
-      await mkdir(longPath, { recursive: true });
-      await writeFile(path.join(longPath, "file.js"), "console.log('long path');");
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["**/*.js"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      const filePaths = result.files;
-      expect(filePaths.some((element) => element.includes(longDirName))).toBe(true);
-    });
-  });
-
-  describe("Error handling and resilience", () => {
-    test("should handle permission denied gracefully", async () => {
-      // This test may not work on all systems, so we wrap in try-catch
-      try {
-        const restrictedDir = path.join(testDir, "restricted");
-        await mkdir(restrictedDir, { recursive: true, mode: 0o000 });
-
-        const result = await loadSources({
-          sourcesPath: restrictedDir,
-          useDefaultPatterns: true,
-          outputDir: tempDir,
-          docsDir: path.join(testDir, "docs"),
-        });
-
-        expect(result.files).toBeDefined();
-        // Should handle gracefully without crashing
-      } catch {
-        // Skip on systems where permission tests don't work
-        expect(true).toBe(true);
-      }
-    });
-
-    test("should handle malformed glob patterns", async () => {
-      const result = await loadSources({
-        sourcesPath: [`${testDir}/[unclosed`, `${testDir}/**/{unclosed`],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      // Should not crash, even with malformed patterns
-      expect(Array.isArray(result.files)).toBe(true);
-    });
-
-    test("should handle circular symbolic links", async () => {
-      try {
-        const { symlink, unlink } = await import("node:fs/promises");
-        const link1 = path.join(testDir, "link1");
-        const link2 = path.join(testDir, "link2");
-
-        // Create circular links
-        await symlink(link2, link1);
-        await symlink(link1, link2);
-
-        const result = await loadSources({
-          sourcesPath: testDir,
-          includePatterns: ["**/*"],
-          useDefaultPatterns: false,
-          outputDir: tempDir,
-          docsDir: path.join(testDir, "docs"),
-        });
-
-        expect(result.files).toBeDefined();
-        // Should handle circular links without infinite loop
-
-        // Clean up circular links immediately to prevent interference with other tests
-        try {
-          await unlink(link1);
-        } catch {
-          // Ignore cleanup errors since they don't affect test results
-        }
-        try {
-          await unlink(link2);
-        } catch {
-          // Ignore cleanup errors since they don't affect test results
-        }
-      } catch {
-        // Skip on systems that don't support symlinks
-        expect(true).toBe(true);
-      }
-    });
-  });
-
-  describe("Integration with generateYAML output", () => {
-    test("should process typical generateYAML sourcesPath configurations", async () => {
-      const typicalConfigs = [
-        ["./src", "./lib"],
-        ["**/*.{js,ts,jsx,tsx}"],
-        ["src/**/*.js", "lib/**/*.ts", "docs/**/*.md"],
-        ["./", "!node_modules", "!dist"],
-      ];
-
-      for (const sourcesPathConfig of typicalConfigs) {
-        const result = await loadSources({
-          sourcesPath: sourcesPathConfig,
-          useDefaultPatterns: true,
-          outputDir: tempDir,
-          docsDir: path.join(testDir, "docs"),
-        });
-
-        expect(result.files).toBeDefined();
-        expect(Array.isArray(result.files)).toBe(true);
-        // Should not crash with any typical config
-      }
-    });
-  });
-
-  describe("File type handling and media assets", () => {
-    test("should handle individual files as sourcesPath", async () => {
-      // Test line 41: stats.isFile() branch
-      const singleFile = path.join(testDir, "single-file.js");
-      await writeFile(singleFile, "console.log('single file');");
-
-      const result = await loadSources({
-        sourcesPath: singleFile,
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      expect(result.files.length).toBe(1);
-      expect(result.files[0]).toContain("single-file.js");
-    });
-
-    test("should process media files correctly", async () => {
-      // Create media files to test lines 151-159
-      const mediaDir = path.join(testDir, "media");
-      await mkdir(mediaDir, { recursive: true });
-
-      await writeFile(path.join(mediaDir, "image.jpg"), "fake image data");
-      await writeFile(path.join(mediaDir, "video.mp4"), "fake video data");
-      await writeFile(path.join(mediaDir, "logo.svg"), "<svg></svg>");
-      await writeFile(path.join(mediaDir, "animation.webp"), "fake webp data");
-
-      const result = await loadSources({
-        sourcesPath: mediaDir,
-        includePatterns: ["**/*"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.assetsContent).toBeDefined();
-      expect(result.assetsContent).toContain("Available Media Assets");
-      expect(result.assetsContent).toContain("image.jpg");
-      expect(result.assetsContent).toContain("video.mp4");
-      expect(result.assetsContent).toContain("logo.svg");
-      expect(result.assetsContent).toContain('type: "image"');
-      expect(result.assetsContent).toContain('type: "video"');
-
-      // Test media file processing logic (lines 243-266)
-      expect(result.assetsContent).toContain("```yaml");
-      expect(result.assetsContent).toContain("assets:");
-    });
-
-    test("should handle glob pattern errors gracefully", async () => {
-      const invalidGlobPattern = "./invalid/**/*.{unclosed";
-
-      const result = await loadSources({
-        sourcesPath: [invalidGlobPattern],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files).toBeDefined();
-      expect(Array.isArray(result.files)).toBe(true);
-      // Should handle gracefully without crashing
-    });
-  });
-
-  describe("Document path and documentation structure handling", () => {
-    test("should load existing documentation structure", async () => {
-      const documentStructure = {
-        sections: ["Introduction", "API", "Examples"],
-        lastUpdated: new Date().toISOString(),
-      };
-
-      await writeFile(path.join(tempDir, "structure-plan.json"), JSON.stringify(documentStructure));
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["*.js"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.originalDocumentStructure).toEqual(documentStructure);
-    });
-
-    test("should handle malformed documentation structure JSON", async () => {
-      await writeFile(path.join(tempDir, "structure-plan.json"), "{ invalid json content");
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["*.js"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.originalDocumentStructure).toBeUndefined();
-    });
-
-    test("should handle non-ENOENT errors when reading documentation structure JSON", async () => {
-      // Import fs promises module to spy on
-      const fsPromises = await import("node:fs/promises");
-
-      // Get the original readFile function
-      const originalReadFile = fsPromises.readFile;
-
-      // Create a spy that only throws error for structure-plan.json
-      const readFileSpy = spyOn(fsPromises, "readFile").mockImplementation((filePath, encoding) => {
-        if (filePath.includes("structure-plan.json")) {
-          const error = new Error("Permission denied");
-          error.code = "EACCES";
-          throw error;
-        }
-        // For all other files, use the original readFile
-        return originalReadFile(filePath, encoding);
-      });
-
-      try {
-        const result = await loadSources({
-          sourcesPath: testDir,
-          includePatterns: ["*.js"],
-          useDefaultPatterns: false,
-          outputDir: tempDir,
-          docsDir: path.join(testDir, "docs"),
-        });
-
-        expect(result.originalDocumentStructure).toBeUndefined();
-      } finally {
-        // Restore the original readFile function
-        readFileSpy.mockRestore();
-      }
-    });
-
-    test("should handle non-ENOENT errors when reading docPath file", async () => {
-      // Import fs promises module to spy on
-      const fsPromises = await import("node:fs/promises");
-
-      // Get the original readFile function
-      const originalReadFile = fsPromises.readFile;
-
-      // Create a spy that only throws error for the specific docPath file
-      const readFileSpy = spyOn(fsPromises, "readFile").mockImplementation((filePath, encoding) => {
-        // Check if this is the docPath file (api-overview.md)
-        if (filePath.includes("api-overview.md")) {
-          const error = new Error("Permission denied");
-          error.code = "EACCES";
-          throw error;
-        }
-        // For all other files, use the original readFile
-        return originalReadFile(filePath, encoding);
-      });
-
-      try {
-        const result = await loadSources({
-          sourcesPath: testDir,
-          "doc-path": "/api/overview",
-          includePatterns: ["*.js"],
-          useDefaultPatterns: false,
-          outputDir: tempDir,
-          docsDir: path.join(testDir, "docs"),
-        });
-
-        expect(result.content).toBeUndefined();
-      } finally {
-        // Restore the original readFile function
-        readFileSpy.mockRestore();
-      }
-    });
-
-    test("should handle non-ENOENT errors when reading boardId-based docPath file", async () => {
-      // Import fs promises module to spy on
-      const fsPromises = await import("node:fs/promises");
-
-      // Get the original readFile function
-      const originalReadFile = fsPromises.readFile;
-
-      // Create a spy that only throws error for the boardId file
-      const readFileSpy = spyOn(fsPromises, "readFile").mockImplementation((filePath, encoding) => {
-        // First call will fail for the original format (board123-api-overview.md)
-        // Second call should fail for the boardId format (api-overview.md)
-        if (filePath.includes("board123-api-overview.md")) {
-          const error = new Error("File not found");
-          error.code = "ENOENT";
-          throw error;
-        }
-        if (filePath.includes("api-overview.md") && !filePath.includes("board123-")) {
-          const error = new Error("Permission denied");
-          error.code = "EACCES";
-          throw error;
-        }
-        // For all other files, use the original readFile
-        return originalReadFile(filePath, encoding);
-      });
-
-      try {
-        const result = await loadSources({
-          sourcesPath: testDir,
-          "doc-path": "board123-api-overview",
-          boardId: "board123",
-          includePatterns: ["*.js"],
-          useDefaultPatterns: false,
-          outputDir: tempDir,
-          docsDir: path.join(testDir, "docs"),
-        });
-
-        expect(result.content).toBeUndefined();
-      } finally {
-        // Restore the original readFile function
-        readFileSpy.mockRestore();
-      }
-    });
-
-    test("should load document content by docPath", async () => {
-      const docsDir = path.join(testDir, "docs");
-      const docContent = "# API Documentation\n\nThis is the API documentation content.";
-
-      await writeFile(path.join(docsDir, "api-overview.md"), docContent);
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        "doc-path": "/api/overview",
-        includePatterns: ["*.md"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: docsDir,
-      });
-
-      expect(result.content).toBe(docContent);
-    });
-
-    test("should handle boardId-based doc path format", async () => {
-      const docsDir = path.join(testDir, "docs");
-      const docContent = "# Board specific documentation";
-
-      await writeFile(path.join(docsDir, "user-guide.md"), docContent);
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        "doc-path": "board123-user-guide",
-        boardId: "board123",
-        includePatterns: ["*.md"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: docsDir,
-      });
-
-      expect(result.content).toBe(docContent);
-    });
-
-    test("should handle non-existent doc path gracefully", async () => {
-      const result = await loadSources({
-        sourcesPath: testDir,
-        "doc-path": "/non-existent/doc",
-        includePatterns: ["*.md"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.content).toBeUndefined();
-    });
-
-    test("should handle includePatterns empty gracefully", async () => {
-      const docsDir = path.join(testDir, "docs");
-      const docContent = "# API Documentation\n\nThis is the API documentation content.";
-
-      await writeFile(path.join(docsDir, "api-overview.md"), docContent);
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        "doc-path": "/api/overview",
-        includePatterns: null,
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: docsDir,
-      });
-
-      expect(result.files?.length).toBe(0);
-    });
-  });
-
-  describe("Token and line counting", () => {
-    test("should count tokens and lines in source content", async () => {
-      // Create files with known content for counting
-      await writeFile(
-        path.join(testDir, "count-test.js"),
-        "// This file has words and lines\nconst message = 'hello world';\nconsole.log(message);\n\n// Another comment\nfunction test() {\n  return true;\n}",
-      );
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["count-test.js"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.totalTokens).toBeGreaterThan(0);
-      expect(result.totalLines).toBeGreaterThan(0);
-      expect(typeof result.totalTokens).toBe("number");
-      expect(typeof result.totalLines).toBe("number");
-    });
-  });
-
-  describe("Media file path and metadata processing", () => {
-    test("should correctly process media file relativePath, fileName, and description", async () => {
-      // Create media files in a specific structure to test the exact logic
-      const mediaSubDir = path.join(testDir, "assets", "images");
-      await mkdir(mediaSubDir, { recursive: true });
-
-      const imageFile = path.join(mediaSubDir, "company-logo.png");
-      const videoFile = path.join(mediaSubDir, "demo-video.mp4");
-      const svgFile = path.join(mediaSubDir, "icon-arrow.svg");
-
-      await writeFile(imageFile, "fake png data");
-      await writeFile(videoFile, "fake video data");
-      await writeFile(svgFile, "<svg>fake svg</svg>");
-
-      const docsDir = path.join(testDir, "docs");
-
-      const result = await loadSources({
-        sourcesPath: mediaSubDir,
-        includePatterns: ["**/*"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: docsDir,
-      });
-
-      expect(result.assetsContent).toBeDefined();
-
-      // Check that relativePath calculation worked (line 151)
-      expect(result.assetsContent).toContain("../assets/images/company-logo.png");
-      expect(result.assetsContent).toContain("../assets/images/demo-video.mp4");
-      expect(result.assetsContent).toContain("../assets/images/icon-arrow.svg");
-
-      // Check that fileName extraction worked (line 152)
-      expect(result.assetsContent).toContain('name: "company-logo.png"');
-      expect(result.assetsContent).toContain('name: "demo-video.mp4"');
-      expect(result.assetsContent).toContain('name: "icon-arrow.svg"');
-
-      // Test with complex filenames to ensure path.parse works correctly
-      const complexFile = path.join(mediaSubDir, "my-complex.file-name.with.dots.jpg");
-      await writeFile(complexFile, "fake jpg data");
-
-      const result2 = await loadSources({
-        sourcesPath: mediaSubDir,
-        includePatterns: ["my-complex.file-name.with.dots.jpg"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: docsDir,
-      });
-
-      expect(result2.assetsContent).toContain('name: "my-complex.file-name.with.dots.jpg"');
-      expect(result2.assetsContent).toContain(
-        "../assets/images/my-complex.file-name.with.dots.jpg",
-      );
-    });
-
-    test("should handle media files with same docsDir path correctly", async () => {
-      // Test when media files are in the same directory as docsDir
-      const docsDir = path.join(testDir, "docs");
-      const mediaFile = path.join(docsDir, "logo.png");
-
-      await writeFile(mediaFile, "fake logo data");
-
-      const result = await loadSources({
-        sourcesPath: docsDir,
-        includePatterns: ["*.png"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: docsDir,
-      });
-
-      // When file is in docsDir, relativePath should be just the filename
-      expect(result.assetsContent).toContain('path: "logo.png"');
-      expect(result.assetsContent).toContain('name: "logo.png"');
-    });
-
-    test("should handle media files in parent directory relative to docsDir", async () => {
-      // Test when media files are in parent directory of docsDir
-      const docsDir = path.join(testDir, "documentation");
-      await mkdir(docsDir, { recursive: true });
-
-      const mediaFile = path.join(testDir, "header-image.jpg");
-      await writeFile(mediaFile, "fake header data");
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["header-image.jpg"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: docsDir,
-      });
-
-      // When file is in parent of docsDir, relativePath should use ../
-      expect(result.assetsContent).toContain('path: "../header-image.jpg"');
-      expect(result.assetsContent).toContain('name: "header-image.jpg"');
-    });
-  });
-
-  describe("Edge cases and error handling", () => {
-    test("should handle empty media files list", async () => {
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["*.js"], // Only include non-media files
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.assetsContent).toBeDefined();
-      expect(result.assetsContent).toContain("Available Media Assets");
-      // Should have basic header even with no media files
-    });
-
-    test("should handle mixed source and media files", async () => {
-      // Create mixed content
-      await writeFile(path.join(testDir, "mixed-test.js"), "console.log('code');");
-      await writeFile(path.join(testDir, "mixed-image.png"), "fake png data");
-      await writeFile(path.join(testDir, "mixed-doc.md"), "# Documentation");
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["mixed-*"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      expect(result.files.length).toBeGreaterThan(0);
-      expect(result.assetsContent).toContain("mixed-image.png");
-
-      // Verify both source files and media files are processed
-      const sourceFiles = result.files;
-      expect(sourceFiles.some((f) => f.includes("mixed-test.js"))).toBe(true);
-      expect(sourceFiles.some((f) => f.includes("mixed-doc.md"))).toBe(true);
-    });
-
-    test("should handle various media file types", async () => {
-      const mediaTypes = [
-        { name: "test.jpg", type: "image" },
-        { name: "test.jpeg", type: "image" },
-        { name: "test.png", type: "image" },
-        { name: "test.gif", type: "image" },
-        { name: "test.webp", type: "image" },
-        { name: "test.svg", type: "image" },
-        { name: "test.mp4", type: "video" },
-        { name: "test.mov", type: "video" },
-        { name: "test.avi", type: "video" },
-        { name: "test.webm", type: "video" },
-      ];
-
-      // Create all media file types
-      for (const media of mediaTypes) {
-        await writeFile(path.join(testDir, media.name), `fake ${media.type} data`);
-      }
-
-      const result = await loadSources({
-        sourcesPath: testDir,
-        includePatterns: ["test.*"],
-        useDefaultPatterns: false,
-        outputDir: tempDir,
-        docsDir: path.join(testDir, "docs"),
-      });
-
-      // Verify all media types are properly categorized
-      for (const media of mediaTypes) {
-        expect(result.assetsContent).toContain(media.name);
-        expect(result.assetsContent).toContain(`type: "${media.type}"`);
-      }
-    });
-  });
-
-  // Global cleanup to ensure test directories are fully removed
-  afterAll(async () => {
-    // Clean up all test-content-generator directories (including unique ones)
-    try {
-      const { readdir } = await import("node:fs/promises");
-      const entries = await readdir(__dirname, { withFileTypes: true });
-
-      for (const entry of entries) {
-        if (entry.isDirectory() && entry.name.startsWith("test-content-generator")) {
-          const testDirToClean = path.join(__dirname, entry.name);
-          try {
-            await rm(testDirToClean, { recursive: true, force: true });
-          } catch {
-            // Try with system command as fallback
-            try {
-              const { exec } = await import("node:child_process");
-              const { promisify } = await import("node:util");
-              const execAsync = promisify(exec);
-              await execAsync(`rm -rf "${testDirToClean}"`);
-            } catch {
-              console.warn(`Warning: Could not fully clean up test directory: ${testDirToClean}`);
-            }
-          }
-        }
-      }
-    } catch (error) {
-      console.warn(`Warning: Could not clean up test directories: ${error.message}`);
-    }
-  });
-});