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

package/tests/utils/blocklet.test.mjs

@@ -1,336 +0,0 @@
-import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import {
-  ComponentNotFoundError,
-  getComponentMountPoint,
-  InvalidBlockletError,
-} from "../../utils/blocklet.mjs";
-
-describe("blocklet", () => {
-  let mockFetch;
-  beforeEach(() => {
-    // Mock global fetch
-    mockFetch = spyOn(global, "fetch").mockResolvedValue({
-      ok: true,
-      json: () => Promise.resolve({ name: "test-repo", description: "Test repo" }),
-      statusText: "OK",
-    });
-  });
-
-  afterEach(() => {
-    mockFetch?.mockRestore();
-  });
-
-  // ERROR CLASSES TESTS
-  describe("InvalidBlockletError", () => {
-    test("should create error with correct properties", () => {
-      const url = "https://example.com";
-      const status = 404;
-      const statusText = "Not Found";
-
-      const error = new InvalidBlockletError(url, status, statusText);
-
-      expect(error).toBeInstanceOf(Error);
-      expect(error.name).toBe("InvalidBlockletError");
-      expect(error.message).toBe(
-        'Invalid application URL: "https://example.com". Unable to fetch configuration.',
-      );
-      expect(error.url).toBe(url);
-      expect(error.status).toBe(status);
-      expect(error.statusText).toBe(statusText);
-    });
-
-    test("should handle null status and statusText", () => {
-      const url = "https://example.com";
-
-      const error = new InvalidBlockletError(url, null, "Network error");
-
-      expect(error.url).toBe(url);
-      expect(error.status).toBeNull();
-      expect(error.statusText).toBe("Network error");
-    });
-
-    test("should be instanceof Error", () => {
-      const error = new InvalidBlockletError("https://example.com");
-      expect(error instanceof Error).toBe(true);
-      expect(error instanceof InvalidBlockletError).toBe(true);
-    });
-  });
-
-  describe("ComponentNotFoundError", () => {
-    test("should create error with correct properties", () => {
-      const did = "z8ia28nJVd6UMcS4dcJf5NLhv3rLmrFCK";
-      const appUrl = "https://example.com";
-
-      const error = new ComponentNotFoundError(did, appUrl);
-
-      expect(error).toBeInstanceOf(Error);
-      expect(error.name).toBe("ComponentNotFoundError");
-      expect(error.message).toBe(
-        'Your website "https://example.com" missing required component to host your docs.',
-      );
-      expect(error.did).toBe(did);
-      expect(error.appUrl).toBe(appUrl);
-    });
-
-    test("should be instanceof Error", () => {
-      const error = new ComponentNotFoundError("test-did", "https://example.com");
-      expect(error instanceof Error).toBe(true);
-      expect(error instanceof ComponentNotFoundError).toBe(true);
-    });
-  });
-
-  // GETCOMPONENTMOUNTPOINT FUNCTION TESTS
-  describe("getComponentMountPoint", () => {
-    const testAppUrl = "https://example.com";
-    const testDid = "z8ia28nJVd6UMcS4dcJf5NLhv3rLmrFCK";
-    const expectedUrl = "https://example.com/__blocklet__.js?type=json";
-
-    test("should return mount point for existing component", async () => {
-      const mockConfig = {
-        componentMountPoints: [
-          { did: "other-did", mountPoint: "/other" },
-          { did: testDid, mountPoint: "/api/discuss" },
-          { did: "another-did", mountPoint: "/another" },
-        ],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockConfig),
-      });
-
-      const result = await getComponentMountPoint(testAppUrl, testDid);
-
-      expect(result).toBe("/api/discuss");
-      expect(mockFetch).toHaveBeenCalledWith(expectedUrl, {
-        method: "GET",
-        headers: { Accept: "application/json" },
-      });
-    });
-
-    // NETWORK ERROR TESTS
-    test("should throw InvalidBlockletError when fetch fails", async () => {
-      mockFetch.mockRejectedValue(new Error("Network timeout"));
-
-      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
-        InvalidBlockletError,
-      );
-
-      try {
-        await getComponentMountPoint(testAppUrl, testDid);
-      } catch (error) {
-        expect(error.url).toBe(testAppUrl);
-        expect(error.status).toBeNull();
-        expect(error.statusText).toBe("Network timeout");
-      }
-    });
-
-    test("should throw InvalidBlockletError when response is not ok", async () => {
-      mockFetch.mockResolvedValue({
-        ok: false,
-        status: 404,
-        statusText: "Not Found",
-      });
-
-      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
-        InvalidBlockletError,
-      );
-
-      try {
-        await getComponentMountPoint(testAppUrl, testDid);
-      } catch (error) {
-        expect(error.url).toBe(testAppUrl);
-        expect(error.status).toBe(404);
-        expect(error.statusText).toBe("Not Found");
-      }
-    });
-
-    test("should throw InvalidBlockletError when JSON parsing fails", async () => {
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.reject(new Error("Invalid JSON")),
-      });
-
-      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
-        InvalidBlockletError,
-      );
-
-      try {
-        await getComponentMountPoint(testAppUrl, testDid);
-      } catch (error) {
-        expect(error.url).toBe(testAppUrl);
-        expect(error.status).toBeNull();
-        expect(error.statusText).toBe("Invalid JSON response");
-      }
-    });
-
-    // COMPONENT NOT FOUND TESTS
-    test("should throw ComponentNotFoundError when component is not found", async () => {
-      const mockConfig = {
-        componentMountPoints: [
-          { did: "other-did", mountPoint: "/other" },
-          { did: "another-did", mountPoint: "/another" },
-        ],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockConfig),
-      });
-
-      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
-        ComponentNotFoundError,
-      );
-
-      try {
-        await getComponentMountPoint(testAppUrl, testDid);
-      } catch (error) {
-        expect(error.did).toBe(testDid);
-        expect(error.appUrl).toBe(testAppUrl);
-      }
-    });
-
-    test("should throw ComponentNotFoundError when componentMountPoints is undefined", async () => {
-      const mockConfig = {};
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockConfig),
-      });
-
-      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
-        ComponentNotFoundError,
-      );
-    });
-
-    test("should throw ComponentNotFoundError when componentMountPoints is empty", async () => {
-      const mockConfig = {
-        componentMountPoints: [],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockConfig),
-      });
-
-      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
-        ComponentNotFoundError,
-      );
-    });
-
-    // EDGE CASES
-    test("should handle component at the beginning of array", async () => {
-      const mockConfig = {
-        componentMountPoints: [
-          { did: testDid, mountPoint: "/first" },
-          { did: "other-did", mountPoint: "/other" },
-        ],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockConfig),
-      });
-
-      const result = await getComponentMountPoint(testAppUrl, testDid);
-      expect(result).toBe("/first");
-    });
-
-    test("should handle component at the end of array", async () => {
-      const mockConfig = {
-        componentMountPoints: [
-          { did: "other-did", mountPoint: "/other" },
-          { did: testDid, mountPoint: "/last" },
-        ],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockConfig),
-      });
-
-      const result = await getComponentMountPoint(testAppUrl, testDid);
-      expect(result).toBe("/last");
-    });
-
-    test("should handle single component", async () => {
-      const mockConfig = {
-        componentMountPoints: [{ did: testDid, mountPoint: "/single" }],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockConfig),
-      });
-
-      const result = await getComponentMountPoint(testAppUrl, testDid);
-      expect(result).toBe("/single");
-    });
-
-    test("should handle complex mount points", async () => {
-      const mockConfig = {
-        componentMountPoints: [{ did: testDid, mountPoint: "/api/v1/discuss-kit/endpoint" }],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockConfig),
-      });
-
-      const result = await getComponentMountPoint(testAppUrl, testDid);
-      expect(result).toBe("/api/v1/discuss-kit/endpoint");
-    });
-
-    test("should handle empty mount point", async () => {
-      const mockConfig = {
-        componentMountPoints: [{ did: testDid, mountPoint: "" }],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockConfig),
-      });
-
-      const result = await getComponentMountPoint(testAppUrl, testDid);
-      expect(result).toBe("");
-    });
-
-    test("should handle null/undefined mount point", async () => {
-      const mockConfig = {
-        componentMountPoints: [{ did: testDid, mountPoint: null }],
-      };
-
-      mockFetch.mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockConfig),
-      });
-
-      const result = await getComponentMountPoint(testAppUrl, testDid);
-      expect(result).toBeNull();
-    });
-
-    // NETWORK TIMEOUT AND RETRY SCENARIOS
-    test("should handle network errors with different error types", async () => {
-      const errorTypes = [
-        new TypeError("Failed to fetch"),
-        new Error("Connection refused"),
-        new Error("Timeout"),
-        new ReferenceError("Network error"),
-      ];
-
-      for (const error of errorTypes) {
-        mockFetch.mockRejectedValueOnce(error);
-
-        try {
-          await getComponentMountPoint(testAppUrl, testDid);
-          expect(true).toBe(false); // Should not reach here
-        } catch (caughtError) {
-          expect(caughtError).toBeInstanceOf(InvalidBlockletError);
-          expect(caughtError.url).toBe(testAppUrl);
-          expect(caughtError.status).toBeNull();
-          expect(caughtError.statusText).toBe(error.message);
-        }
-      }
-    });
-  });
-});

package/tests/utils/conflict-detector.test.mjs

@@ -1,355 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  detectResolvableConflicts,
-  generateConflictResolutionRules,
-  getFilteredOptions,
-} from "../../utils/conflict-detector.mjs";
-import { processConfigFields } from "../../utils/utils.mjs";
-
-describe("conflict-detector", () => {
-  describe("getFilteredOptions", () => {
-    test("should filter experiencedUsers when documentPurpose is getStarted", () => {
-      const allOptions = {
-        completeBeginners: "Complete beginners",
-        domainFamiliar: "Domain familiar",
-        experiencedUsers: "Experienced users",
-        emergencyTroubleshooting: "Emergency troubleshooting",
-      };
-
-      const currentSelections = {
-        documentPurpose: ["getStarted"],
-      };
-
-      const result = getFilteredOptions("readerKnowledgeLevel", currentSelections, allOptions);
-
-      expect(result.filteredOptions).not.toHaveProperty("experiencedUsers");
-      expect(result.appliedFilters).toHaveLength(1);
-      expect(result.appliedFilters[0].removedOption).toBe("experiencedUsers");
-    });
-
-    test("should filter completeBeginners when documentPurpose is findAnswers", () => {
-      const allOptions = {
-        completeBeginners: "Complete beginners",
-        domainFamiliar: "Domain familiar",
-        experiencedUsers: "Experienced users",
-      };
-
-      const currentSelections = {
-        documentPurpose: ["findAnswers"],
-      };
-
-      const result = getFilteredOptions("readerKnowledgeLevel", currentSelections, allOptions);
-
-      expect(result.filteredOptions).not.toHaveProperty("completeBeginners");
-      expect(result.appliedFilters).toHaveLength(1);
-      expect(result.appliedFilters[0].removedOption).toBe("completeBeginners");
-    });
-
-    test("should filter emergencyTroubleshooting when documentPurpose is understandSystem", () => {
-      const allOptions = {
-        completeBeginners: "Complete beginners",
-        emergencyTroubleshooting: "Emergency troubleshooting",
-      };
-
-      const currentSelections = {
-        documentPurpose: ["understandSystem"],
-      };
-
-      const result = getFilteredOptions("readerKnowledgeLevel", currentSelections, allOptions);
-
-      expect(result.filteredOptions).not.toHaveProperty("emergencyTroubleshooting");
-      expect(result.appliedFilters).toHaveLength(1);
-    });
-
-    test("should filter experiencedUsers when targetAudienceTypes includes endUsers", () => {
-      const allOptions = {
-        completeBeginners: "Complete beginners",
-        experiencedUsers: "Experienced users",
-      };
-
-      const currentSelections = {
-        targetAudienceTypes: ["endUsers"],
-      };
-
-      const result = getFilteredOptions("readerKnowledgeLevel", currentSelections, allOptions);
-
-      expect(result.filteredOptions).not.toHaveProperty("experiencedUsers");
-      expect(result.appliedFilters).toHaveLength(1);
-    });
-
-    test("should return original options when no conflicts", () => {
-      const allOptions = {
-        option1: "Option 1",
-        option2: "Option 2",
-      };
-
-      const currentSelections = {};
-
-      const result = getFilteredOptions("unknownType", currentSelections, allOptions);
-
-      expect(result.filteredOptions).toEqual(allOptions);
-      expect(result.appliedFilters).toHaveLength(0);
-    });
-
-    test("should handle object selections with value property", () => {
-      const allOptions = {
-        experiencedUsers: "Experienced users",
-        domainFamiliar: "Domain familiar",
-      };
-
-      const currentSelections = {
-        documentPurpose: [{ value: "getStarted", label: "Get Started" }],
-      };
-
-      const result = getFilteredOptions("readerKnowledgeLevel", currentSelections, allOptions);
-
-      expect(result.filteredOptions).not.toHaveProperty("experiencedUsers");
-      expect(result.appliedFilters).toHaveLength(1);
-    });
-
-    test("should handle multiple conditions in cross-conflict rules", () => {
-      const allOptions = {
-        emergencyTroubleshooting: "Emergency troubleshooting",
-        domainFamiliar: "Domain familiar",
-      };
-
-      const currentSelections = {
-        targetAudienceTypes: ["decisionMakers"],
-      };
-
-      const result = getFilteredOptions("readerKnowledgeLevel", currentSelections, allOptions);
-
-      expect(result.filteredOptions).not.toHaveProperty("emergencyTroubleshooting");
-      expect(result.appliedFilters).toHaveLength(1);
-    });
-  });
-
-  describe("detectResolvableConflicts", () => {
-    test("should detect document purpose conflicts", () => {
-      const config = {
-        documentPurpose: ["getStarted", "findAnswers"],
-        targetAudienceTypes: ["developers"],
-      };
-
-      const conflicts = detectResolvableConflicts(config);
-
-      expect(conflicts).toHaveLength(1);
-      expect(conflicts[0]).toMatchObject({
-        type: "documentPurpose",
-        items: ["getStarted", "findAnswers"],
-        strategy: "layered_structure",
-        description: "Quick start and API reference conflict, resolved through layered structure",
-      });
-    });
-
-    test("should detect target audience conflicts", () => {
-      const config = {
-        documentPurpose: ["completeTasks"],
-        targetAudienceTypes: ["endUsers", "developers"],
-      };
-
-      const conflicts = detectResolvableConflicts(config);
-
-      expect(conflicts).toHaveLength(1);
-      expect(conflicts[0]).toMatchObject({
-        type: "targetAudienceTypes",
-        items: ["endUsers", "developers"],
-        strategy: "separate_user_paths",
-        description: "End users and developers conflict, resolved through separate user paths",
-      });
-    });
-
-    test("should detect multiple conflicts", () => {
-      const config = {
-        documentPurpose: ["getStarted", "findAnswers", "understandSystem"],
-        targetAudienceTypes: ["endUsers", "developers"],
-      };
-
-      const conflicts = detectResolvableConflicts(config);
-
-      expect(conflicts).toHaveLength(3);
-
-      // Check for getStarted vs findAnswers conflict
-      expect(
-        conflicts.some(
-          (c) =>
-            c.type === "documentPurpose" &&
-            c.items.includes("getStarted") &&
-            c.items.includes("findAnswers"),
-        ),
-      ).toBe(true);
-
-      // Check for getStarted vs understandSystem conflict
-      expect(
-        conflicts.some(
-          (c) =>
-            c.type === "documentPurpose" &&
-            c.items.includes("getStarted") &&
-            c.items.includes("understandSystem"),
-        ),
-      ).toBe(true);
-
-      // Check for endUsers vs developers conflict
-      expect(
-        conflicts.some(
-          (c) =>
-            c.type === "targetAudienceTypes" &&
-            c.items.includes("endUsers") &&
-            c.items.includes("developers"),
-        ),
-      ).toBe(true);
-    });
-
-    test("should not detect conflicts with single selections", () => {
-      const config = {
-        documentPurpose: ["getStarted"],
-        targetAudienceTypes: ["developers"],
-      };
-
-      const conflicts = detectResolvableConflicts(config);
-
-      expect(conflicts).toHaveLength(0);
-    });
-
-    test("should not detect conflicts with non-conflicting combinations", () => {
-      const config = {
-        documentPurpose: ["completeTasks", "solveProblems"],
-        targetAudienceTypes: ["developers", "devops"],
-      };
-
-      const conflicts = detectResolvableConflicts(config);
-
-      expect(conflicts).toHaveLength(0);
-    });
-
-    test("should handle object arrays with value property", () => {
-      const config = {
-        documentPurpose: [
-          { value: "getStarted", label: "Get Started" },
-          { value: "findAnswers", label: "Find Answers" },
-        ],
-      };
-
-      const conflicts = detectResolvableConflicts(config);
-
-      expect(conflicts).toHaveLength(1);
-      expect(conflicts[0].items).toEqual(["getStarted", "findAnswers"]);
-    });
-  });
-
-  describe("generateConflictResolutionRules", () => {
-    test("should generate resolution rules for conflicts", () => {
-      const conflicts = [
-        {
-          type: "documentPurpose",
-          items: ["getStarted", "findAnswers"],
-          strategy: "layered_structure",
-          description: "Quick start and API reference conflict, resolved through layered structure",
-        },
-        {
-          type: "targetAudienceTypes",
-          items: ["endUsers", "developers"],
-          strategy: "separate_user_paths",
-          description: "End users and developers conflict, resolved through separate user paths",
-        },
-      ];
-
-      const rules = generateConflictResolutionRules(conflicts);
-
-      expect(rules).toContain("=== Conflict Resolution Guidelines ===");
-      expect(rules).toContain('Detected "getStarted" and "findAnswers" purpose conflict');
-      expect(rules).toContain('Detected "endUsers" and "developers" audience conflict');
-      expect(rules).toContain('Quick start section: Uses "get started" style');
-      expect(rules).toContain('User guide path: Uses "end users" style');
-      expect(rules).toContain("Conflict Resolution Principles:");
-      expect(rules).toContain(
-        "1. Meet diverse needs through intelligent structural design, not simple concatenation",
-      );
-    });
-
-    test("should return empty string for no conflicts", () => {
-      const conflicts = [];
-      const rules = generateConflictResolutionRules(conflicts);
-      expect(rules).toBe("");
-    });
-
-    test("should handle unknown strategies gracefully", () => {
-      const conflicts = [
-        {
-          type: "documentPurpose",
-          items: ["unknown1", "unknown2"],
-          strategy: "unknown_strategy",
-          description: "Unknown conflict",
-        },
-      ];
-
-      const rules = generateConflictResolutionRules(conflicts);
-
-      expect(rules).toContain("=== Conflict Resolution Guidelines ===");
-      expect(rules).toContain("Conflict Resolution Principles:");
-      // Should not contain any strategy-specific text since strategy is unknown
-      expect(rules).not.toContain('Detected "unknown1" and "unknown2"');
-    });
-  });
-
-  describe("processConfigFields integration", () => {
-    test("should integrate conflict resolution into config processing", () => {
-      const config = {
-        documentPurpose: ["getStarted", "findAnswers"],
-        targetAudienceTypes: ["endUsers", "developers"],
-        readerKnowledgeLevel: "completeBeginners",
-        documentationDepth: "balancedCoverage",
-      };
-
-      const result = processConfigFields(config);
-
-      // Should detect conflicts
-      expect(result.detectedConflicts).toBeDefined();
-      expect(result.detectedConflicts).toHaveLength(2);
-
-      // Should include conflict resolution rules in final rules
-      expect(result.rules).toContain("=== Conflict Resolution Guidelines ===");
-      expect(result.rules).toContain("Create layered documentation structure");
-      expect(result.rules).toContain("Create separate user paths");
-
-      // Should also include regular configuration content with enhanced format
-      expect(result.rules).toContain("Document Purpose - Get started quickly:");
-      expect(result.rules).toContain("Target Audience - End users (non-technical):");
-      expect(result.rules).toContain("Target Audience - Developers integrating your product/API:");
-      expect(result.rules).toContain("Reader Knowledge Level:");
-    });
-
-    test("should work without conflicts", () => {
-      const config = {
-        documentPurpose: ["completeTasks"],
-        targetAudienceTypes: ["developers"],
-        readerKnowledgeLevel: "domainFamiliar",
-      };
-
-      const result = processConfigFields(config);
-
-      // Should not detect conflicts
-      expect(result.detectedConflicts).toBeUndefined();
-
-      // Should not include conflict resolution rules
-      expect(result.rules).not.toContain("=== Conflict Resolution Guidelines ===");
-
-      // Should still include regular configuration content with enhanced format
-      expect(result.rules).toContain("Document Purpose - Complete specific tasks:");
-      expect(result.rules).toContain("Target Audience - Developers integrating your product/API:");
-    });
-
-    test("should preserve target audience field processing", () => {
-      const config = {
-        targetAudienceTypes: ["developers", "devops"],
-        targetAudience: "Existing audience description",
-      };
-
-      const result = processConfigFields(config);
-
-      expect(result.targetAudience).toContain("Existing audience description");
-      expect(result.targetAudience).toContain("Developers integrating your product/API");
-      expect(result.targetAudience).toContain("DevOps / SRE / Infrastructure teams");
-    });
-  });
-});