@aigne/doc-smith 0.8.5 → 0.8.7

package/tests/agents/generate/check-need-generate-structure.test.mjs

@@ -0,0 +1,292 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
+import * as fsPromises from "node:fs/promises";
+import checkNeedGenerateStructure from "../../../agents/generate/check-need-generate-structure.mjs";
+
+import * as preferencesUtils from "../../../utils/preferences-utils.mjs";
+import * as utils from "../../../utils/utils.mjs";
+
+describe("check-need-generate-structure", () => {
+  let mockOptions;
+  let originalDocumentStructure;
+
+  // Spies for external dependencies
+  let accessSpy;
+
+  // Spies for internal utils
+  let getActiveRulesForScopeSpy;
+  let getCurrentGitHeadSpy;
+  let hasFileChangesBetweenCommitsSpy;
+  let getProjectInfoSpy;
+  let loadConfigFromFileSpy;
+  let saveValueToConfigSpy;
+
+  beforeEach(() => {
+    // Reset all mocks
+    mock.restore();
+
+    originalDocumentStructure = [
+      { path: "/getting-started", title: "Getting Started" },
+      { path: "/api", title: "API Reference" },
+    ];
+
+    mockOptions = {
+      prompts: {
+        input: mock(async () => ""),
+      },
+      context: {
+        agents: { refineDocumentStructure: {} },
+        invoke: mock(async () => ({
+          documentStructure: originalDocumentStructure,
+          projectName: "Test Project",
+          projectDesc: "Test Description",
+        })),
+      },
+    };
+
+    // Set up spies for internal utils
+    getActiveRulesForScopeSpy = spyOn(preferencesUtils, "getActiveRulesForScope").mockReturnValue(
+      [],
+    );
+    getCurrentGitHeadSpy = spyOn(utils, "getCurrentGitHead").mockReturnValue(null);
+    hasFileChangesBetweenCommitsSpy = spyOn(utils, "hasFileChangesBetweenCommits").mockReturnValue(
+      false,
+    );
+    getProjectInfoSpy = spyOn(utils, "getProjectInfo").mockResolvedValue({
+      name: "Test Project",
+      description: "Test Description",
+      fromGitHub: false,
+    });
+    loadConfigFromFileSpy = spyOn(utils, "loadConfigFromFile").mockResolvedValue({});
+    saveValueToConfigSpy = spyOn(utils, "saveValueToConfig").mockResolvedValue();
+
+    // Set up spy for external dependencies
+    accessSpy = spyOn(fsPromises, "access").mockImplementation(() =>
+      Promise.reject(new Error("File not found")),
+    );
+
+    // Clear prompts mock call history
+    mockOptions.prompts.input.mockClear();
+    mockOptions.context.invoke.mockClear();
+  });
+
+  afterEach(() => {
+    // Restore all spies
+    accessSpy?.mockRestore();
+    getActiveRulesForScopeSpy?.mockRestore();
+    getCurrentGitHeadSpy?.mockRestore();
+    hasFileChangesBetweenCommitsSpy?.mockRestore();
+    getProjectInfoSpy?.mockRestore();
+    loadConfigFromFileSpy?.mockRestore();
+    saveValueToConfigSpy?.mockRestore();
+  });
+
+  test("should return original document structure when no regeneration needed", async () => {
+    // Test when no feedback and no sidebar file exists (default mock behavior)
+    const result = await checkNeedGenerateStructure(
+      { originalDocumentStructure, docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(result).toBeDefined();
+    expect(result.documentStructure).toEqual(originalDocumentStructure);
+    expect(mockOptions.context.invoke).not.toHaveBeenCalled();
+  });
+
+  test("should prompt for user feedback when originalDocumentStructure exists", async () => {
+    const userFeedback = "Need more API documentation";
+    mockOptions.prompts.input.mockImplementation(async () => userFeedback);
+
+    await checkNeedGenerateStructure({ originalDocumentStructure, docsDir: "./docs" }, mockOptions);
+
+    expect(mockOptions.prompts.input).toHaveBeenCalledWith({
+      message: "How can we improve the documentation structure? (press Enter to skip):",
+    });
+    expect(mockOptions.context.invoke).toHaveBeenCalled();
+  });
+
+  test("should skip prompting if feedback is already provided", async () => {
+    const providedFeedback = "Already provided feedback";
+
+    await checkNeedGenerateStructure(
+      { originalDocumentStructure, feedback: providedFeedback, docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(mockOptions.prompts.input).not.toHaveBeenCalled();
+    expect(mockOptions.context.invoke).toHaveBeenCalled();
+  });
+
+  test("should handle empty user feedback input", async () => {
+    mockOptions.prompts.input.mockImplementation(async () => "   ");
+    // Default mock behavior: no sidebar file exists
+
+    const result = await checkNeedGenerateStructure(
+      { originalDocumentStructure, docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(result.documentStructure).toEqual(originalDocumentStructure);
+    expect(mockOptions.context.invoke).not.toHaveBeenCalled();
+  });
+
+  test("should regenerate when _sidebar.md exists", async () => {
+    accessSpy.mockImplementation(() => Promise.resolve());
+
+    await checkNeedGenerateStructure({ originalDocumentStructure, docsDir: "./docs" }, mockOptions);
+
+    expect(mockOptions.context.invoke).toHaveBeenCalled();
+  });
+
+  test("should not regenerate when _sidebar.md does not exist", async () => {
+    // Default mock behavior: file access fails
+
+    const result = await checkNeedGenerateStructure(
+      { originalDocumentStructure, docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(result.documentStructure).toEqual(originalDocumentStructure);
+    expect(mockOptions.context.invoke).not.toHaveBeenCalled();
+  });
+
+  test("should check git changes when lastGitHead is provided", async () => {
+    getCurrentGitHeadSpy.mockImplementation(() => "def456");
+    hasFileChangesBetweenCommitsSpy.mockImplementation(() => true);
+
+    await checkNeedGenerateStructure(
+      { originalDocumentStructure, lastGitHead: "abc123", docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(hasFileChangesBetweenCommitsSpy).toHaveBeenCalledWith("abc123", "def456");
+    expect(mockOptions.context.invoke).toHaveBeenCalled();
+  });
+
+  test("should not regenerate when git head is same", async () => {
+    getCurrentGitHeadSpy.mockImplementation(() => "abc123");
+
+    const result = await checkNeedGenerateStructure(
+      { originalDocumentStructure, lastGitHead: "abc123", docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(result.documentStructure).toEqual(originalDocumentStructure);
+    expect(mockOptions.context.invoke).not.toHaveBeenCalled();
+  });
+
+  test("should force regenerate when forceRegenerate is true", async () => {
+    await checkNeedGenerateStructure(
+      { originalDocumentStructure, forceRegenerate: true, docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(mockOptions.context.invoke).toHaveBeenCalled();
+  });
+
+  test("should include user preferences", async () => {
+    const mockRules = [{ rule: "Structure rule 1" }];
+    getActiveRulesForScopeSpy.mockImplementation(() => mockRules);
+
+    await checkNeedGenerateStructure(
+      { originalDocumentStructure, feedback: "test", docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(getActiveRulesForScopeSpy).toHaveBeenCalledWith("structure", []);
+    expect(mockOptions.context.invoke).toHaveBeenCalled();
+  });
+
+  test("should save project info when appropriate", async () => {
+    mockOptions.context.invoke.mockImplementation(async () => ({
+      documentStructure: originalDocumentStructure,
+      projectName: "New Project Name",
+      projectDesc: "New Description",
+    }));
+
+    const result = await checkNeedGenerateStructure(
+      { originalDocumentStructure, feedback: "test", docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(saveValueToConfigSpy).toHaveBeenCalledWith("projectName", "New Project Name");
+    expect(result.projectInfoMessage).toContain("New Project Name");
+  });
+
+  test("should handle project info save errors", async () => {
+    loadConfigFromFileSpy.mockImplementation(async () => {
+      throw new Error("Config load failed");
+    });
+    const consoleSpy = spyOn(console, "warn").mockImplementation(() => {});
+
+    mockOptions.context.invoke.mockImplementation(async () => ({
+      documentStructure: originalDocumentStructure,
+      projectName: "New Project",
+      projectDesc: "New Description",
+    }));
+
+    const result = await checkNeedGenerateStructure(
+      { originalDocumentStructure, feedback: "test", docsDir: "./docs" },
+      mockOptions,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(result).toBeDefined();
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  test("should return correct structure when no originalDocumentStructure provided", async () => {
+    const newDocumentStructure = [{ path: "/new", title: "New Section" }];
+
+    mockOptions.context.invoke.mockImplementation(async () => ({
+      documentStructure: newDocumentStructure,
+    }));
+
+    const result = await checkNeedGenerateStructure({ docsDir: "./docs" }, mockOptions);
+
+    expect(result.documentStructure).toEqual(newDocumentStructure);
+    expect(result.originalDocumentStructure).toEqual(newDocumentStructure);
+  });
+
+  test("should clear feedback in result", async () => {
+    const result = await checkNeedGenerateStructure(
+      { originalDocumentStructure, feedback: "some feedback", docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(result.feedback).toBe("");
+  });
+
+  test("should preserve documentStructureFeedback", async () => {
+    const feedback = "user submitted feedback";
+
+    const result = await checkNeedGenerateStructure(
+      { originalDocumentStructure, feedback, docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(result.documentStructureFeedback).toBe(feedback);
+  });
+
+  test("should pass through additional parameters", async () => {
+    const additionalParams = {
+      customParam1: "value1",
+      customParam2: "value2",
+    };
+
+    await checkNeedGenerateStructure(
+      {
+        originalDocumentStructure,
+        feedback: "test",
+        docsDir: "./docs",
+        ...additionalParams,
+      },
+      mockOptions,
+    );
+
+    expect(mockOptions.context.invoke).toHaveBeenCalledWith(
+      mockOptions.context.agents.refineDocumentStructure,
+      expect.objectContaining(additionalParams),
+    );
+  });
+});

package/tests/agents/generate/generate-structure.test.mjs

@@ -0,0 +1,51 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { join } from "node:path";
+import { AIAgent } from "@aigne/core";
+import { loadAgent } from "@aigne/core/loader/index.js";
+import { loadModel } from "../../utils/mock-chat-model.mjs";
+
+describe("generateStructure Agent", () => {
+  beforeAll(() => {
+    process.env.AIGNE_OBSERVABILITY_DISABLED = "true";
+  });
+
+  afterAll(() => {
+    delete process.env.AIGNE_OBSERVABILITY_DISABLED;
+  });
+  test("should load agent correctly with proper configuration", async () => {
+    const agent = await loadAgent(
+      join(import.meta.dirname, "../../../agents/generate/generate-structure.yaml"),
+      {
+        model: loadModel,
+      },
+    );
+
+    expect(agent).toBeDefined();
+
+    // Verify agent exists and is correct type
+    expect(agent).toBeDefined();
+    expect(agent).toBeInstanceOf(AIAgent);
+    expect(agent.name).toBe("generateStructure");
+  });
+
+  test("should have instructions loaded from file", async () => {
+    const agent = await loadAgent(
+      join(import.meta.dirname, "../../../agents/generate/generate-structure.yaml"),
+      {
+        model: loadModel,
+      },
+    );
+
+    expect(agent).toBeDefined();
+
+    // Verify instructions are loaded
+    expect(agent.instructions).toBeDefined();
+    const instructions = await agent.instructions.build({});
+    expect(instructions.messages).toBeDefined();
+    expect(instructions.messages.length).toBeGreaterThan(0);
+
+    // The instructions should contain content from the prompt file
+    const systemMessage = instructions.messages.find((m) => m.role === "system");
+    expect(systemMessage).toBeDefined();
+  });
+});

package/tests/{input-generator.test.mjs → agents/init/init.test.mjs}

@@ -3,7 +3,7 @@ import { promises as fs } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { parse as parseYAML } from "yaml";
-import init, { generateYAML } from "../agents/input-generator.mjs";
+import init, { generateYAML } from "../../../agents/init/index.mjs";
 
 describe("generateYAML", () => {
   // Helper function to parse YAML and verify it's valid
@@ -1013,7 +1013,7 @@ describe("init", () => {
         );
 
         // Check that function completed successfully
-        expect(result).toEqual({});
+        expect(result).toBeDefined();
 
         // Check that config file was created
         const configPath = join(tempDir, "config.yaml");
@@ -1068,7 +1068,7 @@ describe("init", () => {
           options,
         );
 
-        expect(result).toEqual({});
+        expect(result).toBeDefined();
 
         // Verify the generated config
         const configPath = join(tempDir, "test-config.yaml");
@@ -1113,7 +1113,7 @@ describe("init", () => {
           options,
         );
 
-        expect(result).toEqual({});
+        expect(result).toBeDefined();
 
         const configPath = join(tempDir, "simple-config.yaml");
         const configContent = await fs.readFile(configPath, "utf8");
@@ -1169,7 +1169,7 @@ describe("init", () => {
             options,
           );
 
-          expect(result).toEqual({});
+          expect(result).toBeDefined();
 
           const configPath = join(tempDir, "config.yaml");
           const configContent = await fs.readFile(configPath, "utf8");
@@ -1214,7 +1214,7 @@ describe("init", () => {
           options,
         );
 
-        expect(result).toEqual({});
+        expect(result).toBeDefined();
 
         const configPath = join(tempDir, "config.yaml");
         const configContent = await fs.readFile(configPath, "utf8");
@@ -1251,7 +1251,7 @@ describe("init", () => {
           options,
         );
 
-        expect(result).toEqual({});
+        expect(result).toBeDefined();
 
         // Config should remain unchanged
         const configContent = await fs.readFile(configPath, "utf8");
@@ -1283,7 +1283,7 @@ describe("init", () => {
           options,
         );
 
-        expect(result).toEqual({});
+        expect(result).toBeDefined();
 
         // Config should be generated since original was empty
         const configContent = await fs.readFile(configPath, "utf8");
@@ -1307,7 +1307,9 @@ describe("init", () => {
             if (options.message.includes("[1/8]") && options.validate) {
               // Test the validation function directly
               const validationResult = options.validate([]);
-              expect(validationResult).toBe("Please select at least one purpose.");
+              expect(validationResult).toBe(
+                "Please choose at least one goal for your documentation.",
+              );
               validateCalled = true;
               // Return valid result after testing validation
               return Promise.resolve(["getStarted"]);
@@ -1326,7 +1328,7 @@ describe("init", () => {
           options,
         );
 
-        expect(result).toEqual({});
+        expect(result).toBeDefined();
         expect(validateCalled).toBe(true);
       } finally {
         await cleanupTempDir(tempDir);
@@ -1346,7 +1348,7 @@ describe("init", () => {
             if (options.message.includes("[2/8]") && options.validate) {
               // Test the validation function for target audience
               const validationResult = options.validate([]);
-              expect(validationResult).toBe("Please select at least one audience.");
+              expect(validationResult).toBe("Please choose at least one audience.");
               audienceValidateCalled = true;
               return Promise.resolve(["developers"]); // Valid result after testing
             }
@@ -1364,7 +1366,7 @@ describe("init", () => {
           options,
         );
 
-        expect(result).toEqual({});
+        expect(result).toBeDefined();
         expect(audienceValidateCalled).toBe(true);
       } finally {
         await cleanupTempDir(tempDir);
@@ -1385,11 +1387,11 @@ describe("init", () => {
             if (options.message.includes("Which is most important?") && options.validate) {
               // Test validation for empty selection
               let validationResult = options.validate([]);
-              expect(validationResult).toBe("Please select at least one priority.");
+              expect(validationResult).toBe("Please choose at least one priority.");
 
               // Test validation for too many selections
               validationResult = options.validate(["getStarted", "completeTasks", "findAnswers"]);
-              expect(validationResult).toBe("Please select maximum 2 priorities.");
+              expect(validationResult).toBe("Please choose maximum 2 priorities.");
 
               // Test validation for valid selection
               validationResult = options.validate(["getStarted", "completeTasks"]);
@@ -1412,7 +1414,7 @@ describe("init", () => {
           options,
         );
 
-        expect(result).toEqual({});
+        expect(result).toBeDefined();
         expect(priorityValidateCalled).toBe(true);
       } finally {
         await cleanupTempDir(tempDir);
@@ -1479,7 +1481,7 @@ describe("init", () => {
           options,
         );
 
-        expect(result).toEqual({});
+        expect(result).toBeDefined();
 
         const configPath = join(tempDir, "config.yaml");
         const configContent = await fs.readFile(configPath, "utf8");
@@ -1524,7 +1526,7 @@ describe("init", () => {
           options,
         );
 
-        expect(result).toEqual({});
+        expect(result).toBeDefined();
       } finally {
         await cleanupTempDir(tempDir);
       }