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

package/tests/agents/clear/clear-document-structure.test.mjs

@@ -1,380 +0,0 @@
-import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import * as fsPromises from "node:fs/promises";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import clearDocumentStructure from "../../../agents/clear/clear-document-structure.mjs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-describe("clear-document-structure", () => {
-  let testDir;
-  let structurePlanPath;
-  let docsDir;
-
-  beforeEach(async () => {
-    // Create a temporary test directory
-    testDir = join(__dirname, "test-clear-structure");
-    await mkdir(testDir, { recursive: true });
-
-    // Create .aigne/doc-smith/output directory structure
-    const outputDir = join(testDir, ".aigne", "doc-smith", "output");
-    await mkdir(outputDir, { recursive: true });
-
-    structurePlanPath = join(outputDir, "structure-plan.json");
-    docsDir = join(testDir, "docs");
-  });
-
-  afterEach(async () => {
-    // Clean up test directory
-    try {
-      await rm(testDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors since they don't affect test results
-    }
-  });
-
-  test("should clear documentation structure only when no docsDir provided", async () => {
-    // Create a test documentation structure file
-    const structurePlan = {
-      documents: [
-        { path: "/intro", title: "Introduction" },
-        { path: "/guide", title: "User Guide" },
-      ],
-    };
-    await writeFile(structurePlanPath, JSON.stringify(structurePlan, null, 2));
-
-    const result = await clearDocumentStructure({ workDir: testDir });
-
-    expect(result.message).toContain("Documentation Structure cleared successfully!");
-    expect(result.hasError).toBe(false);
-    expect(result.clearedCount).toBe(1);
-
-    // Verify documentation structure file is actually deleted
-    const { pathExists } = await import("../../../utils/file-utils.mjs");
-    const exists = await pathExists(structurePlanPath);
-    expect(exists).toBe(false);
-  });
-
-  test("should clear both documentation structure and docs directory when docsDir provided", async () => {
-    // Create documentation structure
-    await writeFile(structurePlanPath, JSON.stringify({ test: "data" }));
-
-    // Create docs directory with files
-    await mkdir(docsDir, { recursive: true });
-    await writeFile(join(docsDir, "index.md"), "# Index");
-    await writeFile(join(docsDir, "guide.md"), "# Guide");
-
-    const result = await clearDocumentStructure({ workDir: testDir, docsDir });
-
-    expect(result.message).toContain("Documentation Structure cleared successfully!");
-    expect(result.clearedCount).toBe(2);
-
-    // Verify both are deleted
-    const { pathExists } = await import("../../../utils/file-utils.mjs");
-    const structureExists = await pathExists(structurePlanPath);
-    const docsExists = await pathExists(docsDir);
-    expect(structureExists).toBe(false);
-    expect(docsExists).toBe(false);
-  });
-
-  test("should handle non-existent documentation structure file", async () => {
-    // Don't create the documentation structure file
-    const result = await clearDocumentStructure({ workDir: testDir });
-
-    expect(result.message).toContain("Documentation Structure already empty.");
-    expect(result.clearedCount).toBe(0);
-    expect(result.hasError).toBe(false);
-  });
-
-  test("should handle non-existent docs directory", async () => {
-    // Create documentation structure but not docs directory
-    await writeFile(structurePlanPath, JSON.stringify({ test: "data" }));
-
-    const nonExistentDocsDir = join(testDir, "non-existent-docs");
-
-    const result = await clearDocumentStructure({
-      workDir: testDir,
-      docsDir: nonExistentDocsDir,
-    });
-
-    expect(result.message).toContain("Documentation Structure cleared successfully!");
-    expect(result.clearedCount).toBe(1); // Only documentation structure cleared
-
-    // Verify documentation structure is deleted
-    const { pathExists } = await import("../../../utils/file-utils.mjs");
-    const exists = await pathExists(structurePlanPath);
-    expect(exists).toBe(false);
-  });
-
-  test("should use current working directory when workDir not provided", async () => {
-    const originalCwd = process.cwd();
-
-    try {
-      // Change to test directory
-      process.chdir(testDir);
-
-      // Create documentation structure in current directory's structure
-      await writeFile(structurePlanPath, JSON.stringify({ test: "data" }));
-
-      const result = await clearDocumentStructure({});
-
-      expect(result.message).toContain("Documentation Structure cleared successfully!");
-      expect(result.clearedCount).toBe(1);
-    } finally {
-      // Restore original working directory
-      process.chdir(originalCwd);
-    }
-  });
-
-  test("should provide correct return structure", async () => {
-    await writeFile(structurePlanPath, JSON.stringify({ test: "data" }));
-
-    const result = await clearDocumentStructure({ workDir: testDir });
-
-    expect(result).toHaveProperty("message");
-    expect(result).toHaveProperty("results");
-    expect(result).toHaveProperty("hasError");
-    expect(result).toHaveProperty("clearedCount");
-    expect(typeof result.message).toBe("string");
-    expect(Array.isArray(result.results)).toBe(true);
-    expect(typeof result.hasError).toBe("boolean");
-    expect(typeof result.clearedCount).toBe("number");
-  });
-
-  test("should have correct input schema", () => {
-    expect(clearDocumentStructure.input_schema).toBeDefined();
-    expect(clearDocumentStructure.input_schema.type).toBe("object");
-    expect(clearDocumentStructure.input_schema.properties.docsDir).toBeDefined();
-    expect(clearDocumentStructure.input_schema.properties.docsDir.type).toBe("string");
-    expect(clearDocumentStructure.input_schema.properties.docsDir.description).toBe(
-      "The documents directory to clear (optional)",
-    );
-    expect(clearDocumentStructure.input_schema.properties.workDir).toBeDefined();
-    expect(clearDocumentStructure.input_schema.properties.workDir.type).toBe("string");
-    expect(clearDocumentStructure.input_schema.properties.workDir.description).toBe(
-      "The working directory (defaults to current directory)",
-    );
-  });
-
-  test("should have correct task metadata", () => {
-    expect(clearDocumentStructure.taskTitle).toBe(
-      "Clear documentation structure and all generated documents",
-    );
-    expect(clearDocumentStructure.description).toBe(
-      "Clear the documentation structure (structure-plan.json) and optionally the documents directory",
-    );
-  });
-
-  test("should handle complex documentation structures", async () => {
-    // Create complex documentation structure
-    const complexStructure = {
-      documents: [
-        {
-          path: "/introduction",
-          title: "Introduction",
-          children: [
-            { path: "/introduction/overview", title: "Overview" },
-            { path: "/introduction/getting-started", title: "Getting Started" },
-          ],
-        },
-        {
-          path: "/api",
-          title: "API Reference",
-          children: [
-            { path: "/api/authentication", title: "Authentication" },
-            { path: "/api/endpoints", title: "Endpoints" },
-          ],
-        },
-      ],
-      metadata: {
-        version: "1.0.0",
-        generated: new Date().toISOString(),
-      },
-    };
-
-    await writeFile(structurePlanPath, JSON.stringify(complexStructure, null, 2));
-
-    // Create corresponding docs structure
-    await mkdir(docsDir, { recursive: true });
-    const nestedDirs = [
-      join(docsDir, "introduction"),
-      join(docsDir, "api"),
-      join(docsDir, "tutorials"),
-    ];
-
-    for (const dir of nestedDirs) {
-      await mkdir(dir, { recursive: true });
-      await writeFile(join(dir, "index.md"), `# ${dir} content`);
-    }
-
-    const result = await clearDocumentStructure({ workDir: testDir, docsDir });
-
-    expect(result.clearedCount).toBe(2);
-    expect(result.hasError).toBe(false);
-
-    // Verify everything is cleaned up
-    const { pathExists } = await import("../../../utils/file-utils.mjs");
-    const structureExists = await pathExists(structurePlanPath);
-    const docsExists = await pathExists(docsDir);
-    expect(structureExists).toBe(false);
-    expect(docsExists).toBe(false);
-  });
-
-  test("should handle paths with special characters", async () => {
-    // Create directory with special characters
-    const specialTestDir = join(__dirname, "test-clear-structure with spaces & symbols");
-    await mkdir(specialTestDir, { recursive: true });
-
-    const specialOutputDir = join(specialTestDir, ".aigne", "doc-smith", "output");
-    await mkdir(specialOutputDir, { recursive: true });
-
-    const specialStructurePath = join(specialOutputDir, "structure-plan.json");
-    await writeFile(specialStructurePath, JSON.stringify({ special: "test" }));
-
-    try {
-      const result = await clearDocumentStructure({ workDir: specialTestDir });
-
-      expect(result.clearedCount).toBe(1);
-      expect(result.hasError).toBe(false);
-
-      // Verify special path works
-      const { pathExists } = await import("../../../utils/file-utils.mjs");
-      const exists = await pathExists(specialStructurePath);
-      expect(exists).toBe(false);
-    } finally {
-      // Clean up special directory
-      try {
-        await rm(specialTestDir, { recursive: true, force: true });
-      } catch {
-        // Ignore cleanup errors
-      }
-    }
-  });
-
-  test("should handle relative and absolute paths for docsDir", async () => {
-    await writeFile(structurePlanPath, JSON.stringify({ test: "data" }));
-
-    // Create docs with relative path reference
-    const relativeDocs = join(testDir, "relative-docs");
-    await mkdir(relativeDocs, { recursive: true });
-    await writeFile(join(relativeDocs, "test.md"), "test content");
-
-    const originalCwd = process.cwd();
-
-    try {
-      process.chdir(testDir);
-      const result = await clearDocumentStructure({
-        workDir: testDir,
-        docsDir: "./relative-docs",
-      });
-
-      expect(result.clearedCount).toBe(2);
-      expect(result.hasError).toBe(false);
-    } finally {
-      process.chdir(originalCwd);
-    }
-  });
-
-  test("should provide detailed results information", async () => {
-    await writeFile(structurePlanPath, JSON.stringify({ test: "data" }));
-    await mkdir(docsDir, { recursive: true });
-    await writeFile(join(docsDir, "test.md"), "test content");
-
-    const result = await clearDocumentStructure({ workDir: testDir, docsDir });
-
-    expect(result.results).toHaveLength(2);
-
-    // Check structure result
-    const structureResult = result.results.find((r) => r.type === "structure");
-    expect(structureResult).toBeDefined();
-    expect(structureResult.cleared).toBe(true);
-    expect(structureResult.message).toContain("documentation structure");
-
-    // Check documents result
-    const docsResult = result.results.find((r) => r.type === "documents");
-    expect(docsResult).toBeDefined();
-    expect(docsResult.cleared).toBe(true);
-    expect(docsResult.message).toContain("documents directory");
-  });
-
-  test("should handle documentation structure file removal errors", async () => {
-    // Create a spy on rm to simulate an error for documentation structure
-    const rmSpy = spyOn(fsPromises, "rm");
-    rmSpy.mockImplementation((path, _options) => {
-      if (path.includes("structure-plan.json")) {
-        throw new Error("Permission denied for documentation structure");
-      }
-      return Promise.resolve();
-    });
-
-    try {
-      const result = await clearDocumentStructure({ workDir: testDir });
-
-      expect(result.hasError).toBe(true);
-      expect(result.message).toContain(
-        "Documentation Structure cleanup finished with some issues.",
-      );
-
-      const structureResult = result.results.find((r) => r.type === "structure");
-      expect(structureResult.error).toBe(true);
-      expect(structureResult.message).toContain("Failed to clear documentation structure");
-      expect(structureResult.message).toContain("Permission denied for documentation structure");
-    } finally {
-      rmSpy.mockRestore();
-    }
-  });
-
-  test("should handle documents directory removal errors", async () => {
-    // Create documentation structure file
-    await writeFile(structurePlanPath, JSON.stringify({ test: "data" }));
-
-    // Create a spy on rm to simulate an error for docs directory
-    const rmSpy = spyOn(fsPromises, "rm");
-    rmSpy.mockImplementation((path, _options) => {
-      if (path === docsDir) {
-        throw new Error("Permission denied for docs directory");
-      }
-      return Promise.resolve();
-    });
-
-    try {
-      const result = await clearDocumentStructure({ workDir: testDir, docsDir });
-
-      expect(result.hasError).toBe(true);
-      expect(result.message).toContain(
-        "Documentation Structure cleanup finished with some issues.",
-      );
-
-      const docsResult = result.results.find((r) => r.type === "documents");
-      expect(docsResult.error).toBe(true);
-      expect(docsResult.message).toContain("Failed to clear documents directory");
-      expect(docsResult.message).toContain("Permission denied for docs directory");
-    } finally {
-      rmSpy.mockRestore();
-    }
-  });
-
-  test("should handle both structure and docs errors simultaneously", async () => {
-    // Create a spy on rm to simulate errors for both operations
-    const rmSpy = spyOn(fsPromises, "rm");
-    rmSpy.mockImplementation(() => {
-      throw new Error("File system error");
-    });
-
-    try {
-      const result = await clearDocumentStructure({ workDir: testDir, docsDir });
-
-      expect(result.hasError).toBe(true);
-      expect(result.message).toContain(
-        "Documentation Structure cleanup finished with some issues.",
-      );
-      expect(result.results).toHaveLength(2);
-
-      // Both operations should have errors
-      expect(result.results.every((r) => r.error)).toBe(true);
-    } finally {
-      rmSpy.mockRestore();
-    }
-  });
-});

package/tests/agents/clear/clear-generated-docs.test.mjs

@@ -1,222 +0,0 @@
-import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import * as fsPromises from "node:fs/promises";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import clearGeneratedDocs from "../../../agents/clear/clear-generated-docs.mjs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-describe("clear-generated-docs", () => {
-  let testDir;
-  let docsDir;
-
-  beforeEach(async () => {
-    // Create a temporary test directory
-    testDir = join(__dirname, "test-clear-docs");
-    await mkdir(testDir, { recursive: true });
-
-    docsDir = join(testDir, "docs");
-    await mkdir(docsDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    // Clean up test directory
-    try {
-      await rm(testDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors since they don't affect test results
-    }
-  });
-
-  test("should clear existing generated documents successfully", async () => {
-    // Create some test files in docs directory
-    const testFiles = ["index.md", "guide.md", "api.md", "README.md"];
-    for (const file of testFiles) {
-      await writeFile(join(docsDir, file), `# ${file} content`);
-    }
-
-    // Create subdirectories with files
-    const subDir = join(docsDir, "advanced");
-    await mkdir(subDir, { recursive: true });
-    await writeFile(join(subDir, "config.md"), "# Config content");
-
-    const result = await clearGeneratedDocs({ docsDir });
-
-    expect(result.cleared).toBe(true);
-    expect(result.message).toContain("Cleared generated documents");
-    expect(result.path).toBeDefined();
-
-    // Verify directory is actually deleted
-    const { pathExists } = await import("../../../utils/file-utils.mjs");
-    const exists = await pathExists(docsDir);
-    expect(exists).toBe(false);
-  });
-
-  test("should handle non-existent documents directory", async () => {
-    const nonExistentDir = join(testDir, "non-existent-docs");
-
-    const result = await clearGeneratedDocs({ docsDir: nonExistentDir });
-
-    expect(result.cleared).toBe(false);
-    expect(result.message).toContain("Generated documents already empty");
-    expect(result.path).toBeDefined();
-  });
-
-  test("should return error message when no docsDir provided", async () => {
-    const result = await clearGeneratedDocs({});
-
-    expect(result.message).toBe("No generated documents directory specified");
-    expect(result).not.toHaveProperty("cleared");
-    expect(result).not.toHaveProperty("path");
-  });
-
-  test("should handle null docsDir", async () => {
-    const result = await clearGeneratedDocs({ docsDir: null });
-
-    expect(result.message).toBe("No generated documents directory specified");
-  });
-
-  test("should handle empty string docsDir", async () => {
-    const result = await clearGeneratedDocs({ docsDir: "" });
-
-    expect(result.message).toBe("No generated documents directory specified");
-  });
-
-  test("should handle undefined docsDir", async () => {
-    const result = await clearGeneratedDocs({ docsDir: undefined });
-
-    expect(result.message).toBe("No generated documents directory specified");
-  });
-
-  test("should provide correct return structure", async () => {
-    await writeFile(join(docsDir, "test.md"), "test content");
-
-    const result = await clearGeneratedDocs({ docsDir });
-
-    expect(result).toHaveProperty("message");
-    expect(result).toHaveProperty("cleared");
-    expect(result).toHaveProperty("path");
-    expect(typeof result.message).toBe("string");
-    expect(typeof result.cleared).toBe("boolean");
-    expect(typeof result.path).toBe("string");
-  });
-
-  test("should have correct input schema", () => {
-    expect(clearGeneratedDocs.input_schema).toBeDefined();
-    expect(clearGeneratedDocs.input_schema.type).toBe("object");
-    expect(clearGeneratedDocs.input_schema.properties.docsDir).toBeDefined();
-    expect(clearGeneratedDocs.input_schema.properties.docsDir.type).toBe("string");
-    expect(clearGeneratedDocs.input_schema.properties.docsDir.description).toBe(
-      "The generated documents directory to clear",
-    );
-    expect(clearGeneratedDocs.input_schema.required).toEqual(["docsDir"]);
-  });
-
-  test("should have correct task metadata", () => {
-    expect(clearGeneratedDocs.taskTitle).toBe("Clear all generated documents");
-    expect(clearGeneratedDocs.description).toBe("Clear the generated documents directory");
-  });
-
-  test("should handle relative paths", async () => {
-    // Create test files
-    await writeFile(join(docsDir, "test.md"), "test content");
-
-    // Use relative path
-    const relativePath = "./docs";
-    const originalCwd = process.cwd();
-
-    try {
-      process.chdir(testDir);
-      const result = await clearGeneratedDocs({ docsDir: relativePath });
-
-      expect(result.cleared).toBe(true);
-      expect(result.message).toContain("Cleared generated documents");
-    } finally {
-      process.chdir(originalCwd);
-    }
-  });
-
-  test("should handle absolute paths", async () => {
-    // Create test files
-    await writeFile(join(docsDir, "test.md"), "test content");
-
-    const result = await clearGeneratedDocs({ docsDir });
-
-    expect(result.cleared).toBe(true);
-    expect(result.message).toContain("Cleared generated documents");
-
-    // Verify absolute path works
-    const { pathExists } = await import("../../../utils/file-utils.mjs");
-    const exists = await pathExists(docsDir);
-    expect(exists).toBe(false);
-  });
-
-  test("should handle complex directory structures", async () => {
-    // Create complex nested structure
-    const nestedDirs = [
-      join(docsDir, "api"),
-      join(docsDir, "guides", "getting-started"),
-      join(docsDir, "tutorials", "advanced"),
-      join(docsDir, ".hidden"),
-    ];
-
-    for (const dir of nestedDirs) {
-      await mkdir(dir, { recursive: true });
-      await writeFile(join(dir, "content.md"), "nested content");
-    }
-
-    // Create files at root level
-    await writeFile(join(docsDir, "index.md"), "root content");
-    await writeFile(join(docsDir, ".gitignore"), "node_modules/");
-
-    const result = await clearGeneratedDocs({ docsDir });
-
-    expect(result.cleared).toBe(true);
-    expect(result.message).toContain("Cleared generated documents");
-
-    // Verify entire structure is deleted
-    const { pathExists } = await import("../../../utils/file-utils.mjs");
-    const exists = await pathExists(docsDir);
-    expect(exists).toBe(false);
-  });
-
-  test("should handle paths with special characters", async () => {
-    // Create directory with special characters
-    const specialDocsDir = join(testDir, "docs with spaces & symbols-123");
-    await mkdir(specialDocsDir, { recursive: true });
-    await writeFile(join(specialDocsDir, "test file.md"), "special content");
-
-    const result = await clearGeneratedDocs({ docsDir: specialDocsDir });
-
-    expect(result.cleared).toBe(true);
-    expect(result.message).toContain("Cleared generated documents");
-
-    // Verify special path is deleted
-    const { pathExists } = await import("../../../utils/file-utils.mjs");
-    const exists = await pathExists(specialDocsDir);
-    expect(exists).toBe(false);
-  });
-
-  test("should handle file system errors gracefully", async () => {
-    // Create some test files first
-    await writeFile(join(docsDir, "test.md"), "test content");
-
-    // Create a spy on rm to simulate an error
-    const rmSpy = spyOn(fsPromises, "rm");
-    rmSpy.mockImplementation(() => {
-      throw new Error("Permission denied");
-    });
-
-    try {
-      const result = await clearGeneratedDocs({ docsDir });
-
-      expect(result.error).toBe(true);
-      expect(result.message).toContain("Failed to clear generated documents");
-      expect(result.message).toContain("Permission denied");
-      expect(result.path).toBeDefined();
-    } finally {
-      rmSpy.mockRestore();
-    }
-  });
-});