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

package/tests/agents/update/user-review-document.test.mjs

@@ -1,582 +0,0 @@
-import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
-import * as markedModule from "marked";
-import userReviewDocument from "../../../agents/update/user-review-document.mjs";
-import * as preferencesUtils from "../../../utils/preferences-utils.mjs";
-
-describe("user-review-document", () => {
-  let mockOptions;
-  let mockContent;
-
-  // Spies for internal utils
-  let getActiveRulesForScopeSpy;
-  let consoleSpy;
-  let consoleErrorSpy;
-  let consoleWarnSpy;
-  let markedLexerSpy;
-  let markedSpy;
-
-  beforeEach(() => {
-    // Reset all mocks
-    mock.restore();
-
-    mockContent =
-      "# Getting Started\n\n## Installation\n\nThis is a test document.\n\n### Prerequisites\n\nSome prerequisites here.";
-
-    mockOptions = {
-      prompts: {
-        select: mock(async () => "finish"),
-        input: mock(async () => ""),
-      },
-      context: {
-        agents: {
-          updateDocumentDetail: {},
-          checkFeedbackRefiner: {},
-        },
-        invoke: mock(async () => ({
-          updatedContent: "# Updated Content\n\nThis is updated content.",
-          operationSummary: "Document updated successfully",
-        })),
-        userContext: {
-          currentContent: "",
-        },
-      },
-    };
-
-    // Set up spies for internal utils
-    getActiveRulesForScopeSpy = spyOn(preferencesUtils, "getActiveRulesForScope").mockReturnValue(
-      [],
-    );
-    consoleSpy = spyOn(console, "log").mockImplementation(() => {});
-    consoleErrorSpy = spyOn(console, "error").mockImplementation(() => {});
-    consoleWarnSpy = spyOn(console, "warn").mockImplementation(() => {});
-
-    // Mock marked library
-    markedLexerSpy = spyOn(markedModule.marked, "lexer").mockImplementation(() => [
-      { type: "heading", depth: 1, text: "Getting Started" },
-      { type: "heading", depth: 2, text: "Installation" },
-      { type: "heading", depth: 3, text: "Prerequisites" },
-    ]);
-    markedSpy = spyOn(markedModule.marked, "setOptions").mockImplementation(() => {});
-
-    // Clear context mock call history
-    mockOptions.prompts.select.mockClear();
-    mockOptions.prompts.input.mockClear();
-    mockOptions.context.invoke.mockClear();
-  });
-
-  afterEach(() => {
-    // Restore all spies
-    getActiveRulesForScopeSpy?.mockRestore();
-    consoleSpy?.mockRestore();
-    consoleErrorSpy?.mockRestore();
-    consoleWarnSpy?.mockRestore();
-    markedLexerSpy?.mockRestore();
-    markedSpy?.mockRestore();
-  });
-
-  // CONTENT VALIDATION TESTS
-  test("should return original content when no content provided", async () => {
-    const result = await userReviewDocument({}, mockOptions);
-
-    expect(result).toBeDefined();
-    expect(result.content).toBeUndefined();
-    expect(mockOptions.prompts.select).not.toHaveBeenCalled();
-    expect(consoleSpy).toHaveBeenCalledWith("Please provide document content to review.");
-  });
-
-  test("should return original content when empty content provided", async () => {
-    const result = await userReviewDocument({ content: "" }, mockOptions);
-
-    expect(result).toBeDefined();
-    expect(result.content).toBe("");
-    expect(mockOptions.prompts.select).not.toHaveBeenCalled();
-    expect(consoleSpy).toHaveBeenCalledWith("Please provide document content to review.");
-  });
-
-  test("should return original content when only whitespace provided", async () => {
-    const result = await userReviewDocument({ content: "   \n\t  " }, mockOptions);
-
-    expect(result).toBeDefined();
-    expect(result.content).toBe("   \n\t  ");
-    expect(mockOptions.prompts.select).not.toHaveBeenCalled();
-    expect(consoleSpy).toHaveBeenCalledWith("Please provide document content to review.");
-  });
-
-  // HEADING EXTRACTION TESTS
-  test("should extract markdown headings correctly", async () => {
-    mockOptions.prompts.select.mockImplementation(async () => "finish");
-
-    const result = await userReviewDocument(
-      { content: mockContent, title: "Test Doc" },
-      mockOptions,
-    );
-
-    expect(result).toBeDefined();
-    expect(result.content).toBe(mockContent);
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Current Document: Test Doc"));
-    expect(markedLexerSpy).toHaveBeenCalledWith(mockContent);
-  });
-
-  test("should handle markdown parsing errors with fallback", async () => {
-    markedLexerSpy.mockImplementation(() => {
-      throw new Error("Parsing error");
-    });
-
-    mockOptions.prompts.select.mockImplementation(async () => "finish");
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(result).toBeDefined();
-    expect(result.content).toBe(mockContent);
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      "Failed to parse markdown with marked library, falling back to regex:",
-      "Parsing error",
-    );
-  });
-
-  test("should handle empty content in heading extraction", async () => {
-    const emptyContent = "";
-    mockOptions.prompts.select.mockImplementation(async () => "finish");
-
-    markedLexerSpy.mockReturnValue([]);
-
-    const result = await userReviewDocument({ content: emptyContent }, mockOptions);
-
-    expect(result.content).toBe(emptyContent);
-    expect(consoleSpy).toHaveBeenCalledWith("Please provide document content to review.");
-  });
-
-  // USER INTERACTION TESTS
-  test("should finish immediately when user selects finish", async () => {
-    mockOptions.prompts.select.mockImplementation(async () => "finish");
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(result.content).toBe(mockContent);
-    expect(mockOptions.prompts.select).toHaveBeenCalledTimes(1);
-    expect(mockOptions.prompts.input).not.toHaveBeenCalled();
-    expect(mockOptions.context.invoke).not.toHaveBeenCalled();
-  });
-
-  test("should show document details when user selects view", async () => {
-    mockOptions.prompts.select.mockImplementation(async () => "view");
-    mockOptions.prompts.input.mockImplementation(async () => ""); // Empty feedback after view
-
-    // Mock the marked function directly
-    const markedFunctionSpy = spyOn(markedModule, "marked").mockReturnValue(
-      "Rendered markdown content",
-    );
-
-    const result = await userReviewDocument(
-      { content: mockContent, title: "Test Doc" },
-      mockOptions,
-    );
-
-    expect(result.content).toBe(mockContent);
-    expect(mockOptions.prompts.select).toHaveBeenCalledTimes(1);
-    expect(mockOptions.prompts.input).toHaveBeenCalledTimes(1);
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Document: Test Doc"));
-
-    markedFunctionSpy?.mockRestore();
-  });
-
-  test("should handle marked-terminal rendering errors gracefully", async () => {
-    mockOptions.prompts.select.mockImplementation(async () => "view");
-    mockOptions.prompts.input.mockImplementation(async () => ""); // Empty feedback after view
-
-    // Mock the marked function to throw error
-    const markedFunctionSpy = spyOn(markedModule, "marked").mockImplementation(() => {
-      throw new Error("Rendering error");
-    });
-
-    const result = await userReviewDocument(
-      { content: mockContent, title: "Test Doc" },
-      mockOptions,
-    );
-
-    expect(result.content).toBe(mockContent);
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Falling back to plain text display"),
-    );
-
-    markedFunctionSpy?.mockRestore();
-  });
-
-  // FEEDBACK PROCESSING TESTS
-  test("should process user feedback and update content", async () => {
-    const feedback = "Please add more examples";
-    const updatedContent = "# Updated Content\n\nThis has more examples.";
-
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input
-      .mockImplementationOnce(async () => feedback)
-      .mockImplementationOnce(async () => ""); // Exit loop
-
-    mockOptions.context.invoke.mockImplementation(async () => {
-      // Simulate the agent updating the shared context
-      mockOptions.context.userContext.currentContent = updatedContent;
-      return {
-        updatedContent,
-        operationSummary: "Added examples successfully",
-      };
-    });
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(mockOptions.context.invoke).toHaveBeenCalledWith(
-      mockOptions.context.agents.updateDocumentDetail,
-      expect.objectContaining({
-        originalContent: mockContent,
-        feedback: feedback,
-        userPreferences: "",
-      }),
-    );
-    expect(result.content).toBe(updatedContent);
-  });
-
-  test("should handle empty feedback by exiting loop", async () => {
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input.mockImplementation(async () => "");
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(result.content).toBe(mockContent);
-    expect(mockOptions.context.invoke).not.toHaveBeenCalled();
-  });
-
-  test("should handle whitespace-only feedback by exiting loop", async () => {
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input.mockImplementation(async () => "   \n\t  ");
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(result.content).toBe(mockContent);
-    expect(mockOptions.context.invoke).not.toHaveBeenCalled();
-  });
-
-  // USER PREFERENCES TESTS
-  test("should include user preferences in update call", async () => {
-    const feedback = "Improve clarity";
-    const mockRules = [{ rule: "Keep sections concise" }, { rule: "Use clear headings" }];
-    const expectedPreferences = "Keep sections concise\n\nUse clear headings";
-
-    getActiveRulesForScopeSpy
-      .mockImplementationOnce(() => mockRules) // document rules
-      .mockImplementationOnce(() => []); // global rules
-
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input
-      .mockImplementationOnce(async () => feedback)
-      .mockImplementationOnce(async () => "");
-
-    await userReviewDocument({ content: mockContent, path: "/test-doc" }, mockOptions);
-
-    expect(getActiveRulesForScopeSpy).toHaveBeenCalledWith("document", ["/test-doc"]);
-    expect(getActiveRulesForScopeSpy).toHaveBeenCalledWith("global");
-    expect(mockOptions.context.invoke).toHaveBeenCalledWith(
-      mockOptions.context.agents.updateDocumentDetail,
-      expect.objectContaining({
-        userPreferences: expectedPreferences,
-      }),
-    );
-  });
-
-  test("should combine document and global rules correctly", async () => {
-    const feedback = "Add examples";
-    const documentRules = [{ rule: "Document rule 1" }];
-    const globalRules = [{ rule: "Global rule 1" }, { rule: "Global rule 2" }];
-    const expectedPreferences = "Document rule 1\n\nGlobal rule 1\n\nGlobal rule 2";
-
-    getActiveRulesForScopeSpy
-      .mockImplementationOnce(() => documentRules)
-      .mockImplementationOnce(() => globalRules);
-
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input
-      .mockImplementationOnce(async () => feedback)
-      .mockImplementationOnce(async () => "");
-
-    await userReviewDocument({ content: mockContent, path: "/test-doc" }, mockOptions);
-
-    expect(mockOptions.context.invoke).toHaveBeenCalledWith(
-      mockOptions.context.agents.updateDocumentDetail,
-      expect.objectContaining({
-        userPreferences: expectedPreferences,
-      }),
-    );
-  });
-
-  // AGENT ERROR HANDLING TESTS
-  test("should handle missing updateDocumentDetail agent", async () => {
-    const feedback = "Some feedback";
-    mockOptions.context.agents = {}; // No updateDocumentDetail agent
-
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input.mockImplementation(async () => feedback);
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(result.content).toBe(mockContent);
-    expect(consoleSpy).toHaveBeenCalledWith(
-      "We can't process your feedback right now. The document update feature is temporarily unavailable.",
-    );
-    expect(consoleSpy).toHaveBeenCalledWith(
-      "Please try again later or contact support if this continues.",
-    );
-  });
-
-  test("should handle updateDocumentDetail agent errors", async () => {
-    const feedback = "Some feedback";
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input
-      .mockImplementationOnce(async () => feedback)
-      .mockImplementationOnce(async () => "");
-
-    mockOptions.context.invoke.mockImplementation(async () => {
-      const error = new Error("Agent failed");
-      error.name = "AgentError";
-      error.stack = "Stack trace here";
-      throw error;
-    });
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(result.content).toBe(mockContent);
-    expect(consoleErrorSpy).toHaveBeenCalledWith("Error processing your feedback:");
-    expect(consoleErrorSpy).toHaveBeenCalledWith("Type: AgentError");
-    expect(consoleErrorSpy).toHaveBeenCalledWith("Message: Agent failed");
-    expect(consoleErrorSpy).toHaveBeenCalledWith("Stack: Stack trace here");
-  });
-
-  test("should handle updateDocumentDetail agent returning no content", async () => {
-    const feedback = "Some feedback";
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input
-      .mockImplementationOnce(async () => feedback)
-      .mockImplementationOnce(async () => "");
-
-    // Agent doesn't update the shared context (simulating failure)
-    mockOptions.context.invoke.mockImplementation(async () => ({})); // No updatedContent
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    // Content should remain unchanged since agent didn't update it
-    expect(result.content).toBe(mockContent);
-  });
-
-  // FEEDBACK REFINER TESTS
-  test("should call checkFeedbackRefiner agent when available", async () => {
-    const feedback = "Improve examples";
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input
-      .mockImplementationOnce(async () => feedback)
-      .mockImplementationOnce(async () => "");
-
-    mockOptions.context.invoke
-      .mockImplementationOnce(async () => ({
-        updatedContent: "Updated content",
-        operationSummary: "Updated successfully",
-      })) // updateDocumentDetail
-      .mockImplementationOnce(async () => ({})); // checkFeedbackRefiner
-
-    await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(mockOptions.context.invoke).toHaveBeenCalledWith(
-      mockOptions.context.agents.checkFeedbackRefiner,
-      expect.objectContaining({
-        documentContentFeedback: feedback,
-        stage: "document_refine",
-      }),
-    );
-  });
-
-  test("should handle missing checkFeedbackRefiner agent gracefully", async () => {
-    const feedback = "Some feedback";
-    const updatedContent = "# Updated Content\n\nThis is updated content.";
-    mockOptions.context.agents = { updateDocumentDetail: {} }; // No checkFeedbackRefiner
-
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input
-      .mockImplementationOnce(async () => feedback)
-      .mockImplementationOnce(async () => "");
-
-    mockOptions.context.invoke.mockImplementation(async () => {
-      mockOptions.context.userContext.currentContent = updatedContent;
-      return { updatedContent, operationSummary: "Updated" };
-    });
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(mockOptions.context.invoke).toHaveBeenCalledTimes(1); // Only updateDocumentDetail called
-    expect(result.content).toBe(updatedContent);
-  });
-
-  test("should handle checkFeedbackRefiner errors gracefully", async () => {
-    const feedback = "Some feedback";
-    const updatedContent = "Updated content";
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input
-      .mockImplementationOnce(async () => feedback)
-      .mockImplementationOnce(async () => "");
-
-    mockOptions.context.invoke
-      .mockImplementationOnce(async () => {
-        mockOptions.context.userContext.currentContent = updatedContent;
-        return {
-          updatedContent,
-          operationSummary: "Updated successfully",
-        };
-      }) // updateDocumentDetail
-      .mockImplementationOnce(async () => {
-        throw new Error("Refiner failed");
-      }); // checkFeedbackRefiner
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(result.content).toBe(updatedContent);
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      "We couldn't save your feedback as a preference:",
-      "Refiner failed",
-    );
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      "Your feedback was applied, but we couldn't save it as a preference.",
-    );
-  });
-
-  // MULTIPLE ROUNDS TESTS
-  test("should handle multiple feedback rounds", async () => {
-    const firstFeedback = "Add more examples";
-    const secondFeedback = "Improve clarity";
-    const firstUpdate = "# Content with examples";
-    const secondUpdate = "# Clear content with examples";
-
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input
-      .mockImplementationOnce(async () => firstFeedback)
-      .mockImplementationOnce(async () => secondFeedback)
-      .mockImplementationOnce(async () => ""); // Exit loop
-
-    let invokeCount = 0;
-    mockOptions.context.invoke.mockImplementation(async () => {
-      invokeCount++;
-      if (invokeCount === 1) {
-        // First update
-        mockOptions.context.userContext.currentContent = firstUpdate;
-        return { updatedContent: firstUpdate, operationSummary: "Added examples" };
-      } else if (invokeCount === 2) {
-        // First refiner
-        return {};
-      } else if (invokeCount === 3) {
-        // Second update
-        mockOptions.context.userContext.currentContent = secondUpdate;
-        return { updatedContent: secondUpdate, operationSummary: "Improved clarity" };
-      } else {
-        // Second refiner
-        return {};
-      }
-    });
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(mockOptions.context.invoke).toHaveBeenCalledTimes(4);
-    expect(result.content).toBe(secondUpdate);
-  });
-
-  test("should stop at maximum iterations to prevent infinite loops", async () => {
-    mockOptions.prompts.select.mockImplementation(async () => "feedback");
-    mockOptions.prompts.input.mockImplementation(async () => "Keep giving feedback");
-
-    // Mock a long running process
-    let callCount = 0;
-    mockOptions.context.invoke.mockImplementation(async () => {
-      callCount++;
-      return {
-        updatedContent: `Updated content ${callCount}`,
-        operationSummary: `Update ${callCount}`,
-      };
-    });
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    // Should have stopped due to MAX_ITERATIONS (100)
-    expect(mockOptions.prompts.input).toHaveBeenCalledTimes(100);
-    expect(result.content).toBeDefined();
-  });
-
-  // EDGE CASES
-  test("should handle document with no title", async () => {
-    mockOptions.prompts.select.mockImplementation(async () => "finish");
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(result.content).toBe(mockContent);
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Untitled Document"));
-  });
-
-  test("should handle nested tokens in marked parsing", async () => {
-    const tokensWithNested = [
-      {
-        type: "heading",
-        depth: 1,
-        text: "Main Heading",
-      },
-      {
-        type: "list",
-        items: [],
-        tokens: [
-          {
-            type: "heading",
-            depth: 2,
-            text: "Nested Heading",
-          },
-        ],
-      },
-    ];
-
-    markedLexerSpy.mockReturnValue(tokensWithNested);
-    mockOptions.prompts.select.mockImplementation(async () => "finish");
-
-    const result = await userReviewDocument({ content: mockContent }, mockOptions);
-
-    expect(result.content).toBe(mockContent);
-    // Should process both the main heading and nested heading
-    expect(markedLexerSpy).toHaveBeenCalledWith(mockContent);
-  });
-
-  test("should handle non-string content gracefully", async () => {
-    const result = await userReviewDocument({ content: null }, mockOptions);
-
-    expect(result.content).toBeNull();
-    expect(consoleSpy).toHaveBeenCalledWith("Please provide document content to review.");
-  });
-
-  // FALLBACK HEADING EXTRACTION TESTS
-  test("should use fallback regex extraction when marked fails", async () => {
-    const contentWithHeadings = "# Title\n## Section\n### Subsection\nContent here.";
-    markedLexerSpy.mockImplementation(() => {
-      throw new Error("Marked failed");
-    });
-
-    mockOptions.prompts.select.mockImplementation(async () => "finish");
-
-    const result = await userReviewDocument({ content: contentWithHeadings }, mockOptions);
-
-    expect(result.content).toBe(contentWithHeadings);
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      "Failed to parse markdown with marked library, falling back to regex:",
-      "Marked failed",
-    );
-  });
-
-  test("should handle content with no headings", async () => {
-    const contentNoHeadings = "Just some plain text content without any headings.";
-    markedLexerSpy.mockReturnValue([]);
-
-    mockOptions.prompts.select.mockImplementation(async () => "finish");
-
-    const result = await userReviewDocument({ content: contentNoHeadings }, mockOptions);
-
-    expect(result.content).toBe(contentNoHeadings);
-    expect(consoleSpy).toHaveBeenCalledWith("  This document has no headings.");
-  });
-});

package/tests/agents/utils/action-success.test.mjs

@@ -1,54 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import actionSuccess from "../../../agents/utils/action-success.mjs";
-
-describe("action-success", () => {
-  test("should return success message with action name", async () => {
-    const result = await actionSuccess({ action: "✅ Document generation successfully" });
-
-    expect(result).toBeDefined();
-    expect(result).toHaveProperty("message");
-    expect(result.message).toBe("✅ Document generation successfully");
-  });
-
-  test("should handle different action names", async () => {
-    const actions = [
-      "Configuration setup",
-      "File processing",
-      "Translation generation",
-      "Markdown validation",
-    ];
-
-    for (const action of actions) {
-      const result = await actionSuccess({ action });
-
-      expect(result).toBeDefined();
-      expect(result.message).toBe(`${action}`);
-    }
-  });
-
-  test("should handle empty action name", async () => {
-    const result = await actionSuccess({ action: "" });
-
-    expect(result).toBeDefined();
-    expect(result.message).toBe("");
-  });
-
-  test("should handle undefined action", async () => {
-    const result = await actionSuccess({ action: undefined });
-
-    expect(result).toBeDefined();
-    expect(result.message).toBe("undefined");
-  });
-
-  test("should have task_render_mode property", () => {
-    expect(actionSuccess.task_render_mode).toBe("hide");
-  });
-
-  test("should handle mermaid worker pool shutdown gracefully", async () => {
-    // This test ensures the function doesn't throw even if worker pool fails
-    const result = await actionSuccess({ action: "Test action" });
-
-    expect(result).toBeDefined();
-    expect(result.message).toBe("Test action");
-  });
-});