@aigne/doc-smith 0.8.12-beta.3 → 0.8.12-beta.5

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

@@ -35,10 +35,13 @@ describe("check-need-generate-structure", () => {
     mockOptions = {
       prompts: {
         input: mock(async () => ""),
-        select: mock(async () => ""),
+        select: mock(async () => "generate"),
       },
       context: {
-        agents: { refineDocumentStructure: {} },
+        agents: {
+          generateStructure: {},
+          generateStructureWithoutTools: {},
+        },
         invoke: mock(async () => ({
           documentStructure: originalDocumentStructure,
           projectName: "Test Project",
@@ -99,69 +102,22 @@ describe("check-need-generate-structure", () => {
     expect(mockOptions.context.invoke).not.toHaveBeenCalled();
   });
 
-  test("should handle pre-existing feedback without prompting", 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
-
+  test("should return original structure when it exists and no force regenerate", async () => {
     const result = await checkNeedGenerateStructure(
       { originalDocumentStructure, docsDir: "./docs" },
       mockOptions,
     );
 
-    expect(result.documentStructure).toEqual(originalDocumentStructure);
+    expect(mockOptions.prompts.input).not.toHaveBeenCalled();
     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");
+  test("should handle empty user feedback input", async () => {
+    mockOptions.prompts.input.mockImplementation(async () => "   ");
 
     const result = await checkNeedGenerateStructure(
-      { originalDocumentStructure, lastGitHead: "abc123", docsDir: "./docs" },
+      { originalDocumentStructure, docsDir: "./docs" },
       mockOptions,
     );
 
@@ -178,12 +134,12 @@ describe("check-need-generate-structure", () => {
     expect(mockOptions.context.invoke).toHaveBeenCalled();
   });
 
-  test("should include user preferences", async () => {
+  test("should include user preferences when generating", async () => {
     const mockRules = [{ rule: "Structure rule 1" }];
     getActiveRulesForScopeSpy.mockImplementation(() => mockRules);
 
     await checkNeedGenerateStructure(
-      { originalDocumentStructure, feedback: "test", docsDir: "./docs" },
+      { originalDocumentStructure, forceRegenerate: true, docsDir: "./docs" },
       mockOptions,
     );
 
@@ -199,7 +155,7 @@ describe("check-need-generate-structure", () => {
     }));
 
     const result = await checkNeedGenerateStructure(
-      { originalDocumentStructure, feedback: "test", docsDir: "./docs" },
+      { originalDocumentStructure, forceRegenerate: true, docsDir: "./docs" },
       mockOptions,
     );
 
@@ -220,7 +176,7 @@ describe("check-need-generate-structure", () => {
     }));
 
     const result = await checkNeedGenerateStructure(
-      { originalDocumentStructure, feedback: "test", docsDir: "./docs" },
+      { originalDocumentStructure, forceRegenerate: true, docsDir: "./docs" },
       mockOptions,
     );
 
@@ -243,16 +199,21 @@ describe("check-need-generate-structure", () => {
     expect(result.originalDocumentStructure).toEqual(newDocumentStructure);
   });
 
-  test("should clear feedback in result", async () => {
+  test("should clear feedback in result when regenerating", async () => {
     const result = await checkNeedGenerateStructure(
-      { originalDocumentStructure, feedback: "some feedback", docsDir: "./docs" },
+      {
+        originalDocumentStructure,
+        forceRegenerate: true,
+        feedback: "some feedback",
+        docsDir: "./docs",
+      },
       mockOptions,
     );
 
     expect(result.feedback).toBe("");
   });
 
-  test("should pass through additional parameters", async () => {
+  test("should pass through additional parameters when regenerating", async () => {
     const additionalParams = {
       customParam1: "value1",
       customParam2: "value2",
@@ -261,7 +222,7 @@ describe("check-need-generate-structure", () => {
     await checkNeedGenerateStructure(
       {
         originalDocumentStructure,
-        feedback: "test",
+        forceRegenerate: true,
         docsDir: "./docs",
         ...additionalParams,
       },
@@ -269,7 +230,7 @@ describe("check-need-generate-structure", () => {
     );
 
     expect(mockOptions.context.invoke).toHaveBeenCalledWith(
-      mockOptions.context.agents.refineDocumentStructure,
+      mockOptions.context.agents.generateStructureWithoutTools,
       expect.objectContaining(additionalParams),
     );
   });
@@ -286,4 +247,33 @@ describe("check-need-generate-structure", () => {
     expect(mockOptions.prompts.select).toHaveBeenCalled();
     expect(mockOptions.context.invoke).not.toHaveBeenCalled();
   });
+
+  test("should use generateStructure agent when isLargeContext is true", async () => {
+    await checkNeedGenerateStructure(
+      { originalDocumentStructure, forceRegenerate: true, isLargeContext: true, docsDir: "./docs" },
+      mockOptions,
+    );
+
+    expect(mockOptions.context.invoke).toHaveBeenCalledWith(
+      mockOptions.context.agents.generateStructure,
+      expect.any(Object),
+    );
+  });
+
+  test("should use generateStructureWithoutTools agent when isLargeContext is false", async () => {
+    await checkNeedGenerateStructure(
+      {
+        originalDocumentStructure,
+        forceRegenerate: true,
+        isLargeContext: false,
+        docsDir: "./docs",
+      },
+      mockOptions,
+    );
+
+    expect(mockOptions.context.invoke).toHaveBeenCalledWith(
+      mockOptions.context.agents.generateStructureWithoutTools,
+      expect.any(Object),
+    );
+  });
 });

package/tests/agents/generate/document-structure-tools/generate-sub-structure.test.mjs

@@ -0,0 +1,277 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import generateSubStructure from "../../../../agents/generate/document-structure-tools/generate-sub-structure.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+describe("generate-sub-structure", () => {
+  let testDir;
+
+  beforeEach(async () => {
+    testDir = join(__dirname, "test-generate-sub-structure");
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    try {
+      await rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe("generateSubStructure function", () => {
+    test("should return empty subStructure when subSourcePaths is empty", async () => {
+      const result = await generateSubStructure(
+        {
+          parentDocument: {
+            title: "Test Parent",
+            description: "Test Description",
+            path: "/test",
+            parentId: "parent-1",
+            sourceIds: [],
+          },
+          subSourcePaths: [],
+        },
+        {},
+      );
+
+      expect(result).toBeDefined();
+      expect(result.subStructure).toBeDefined();
+      expect(Array.isArray(result.subStructure)).toBe(true);
+      expect(result.subStructure.length).toBe(0);
+      expect(result.message).toBeUndefined();
+    });
+
+    test("should process single source path with small context", async () => {
+      const testFile = join(testDir, "test.js");
+      await writeFile(testFile, "// Small test file\nconst x = 1;");
+
+      const mockContext = {
+        agents: {
+          generateStructureWithoutTools: "mock-agent-without-tools",
+        },
+        invoke: async (agent, params) => {
+          expect(agent).toBe("mock-agent-without-tools");
+          expect(params.isSubStructure).toBe(true);
+          expect(params.parentDocument).toBeDefined();
+          expect(params.datasources).toBeDefined();
+          expect(params.allFilesPaths).toBeDefined();
+          expect(params.isLargeContext).toBe(false);
+          expect(params.files).toBeDefined();
+          expect(params.totalTokens).toBeGreaterThan(0);
+
+          return {
+            documentStructure: [
+              {
+                title: "Test Document",
+                path: "/test-doc",
+                description: "Generated from test file",
+              },
+            ],
+          };
+        },
+      };
+
+      const result = await generateSubStructure(
+        {
+          parentDocument: {
+            title: "Parent",
+            path: "/parent",
+            description: "Parent doc",
+          },
+          subSourcePaths: [{ path: testFile, reason: "Test file" }],
+        },
+        { context: mockContext },
+      );
+
+      expect(result).toBeDefined();
+      expect(result.subStructure).toBeDefined();
+      expect(Array.isArray(result.subStructure)).toBe(true);
+      expect(result.subStructure.length).toBe(1);
+      expect(result.message).toContain("Generated a sub structure");
+      expect(result.message).toContain("/parent");
+    });
+
+    test("should process multiple source paths", async () => {
+      const testFile1 = join(testDir, "test1.js");
+      const testFile2 = join(testDir, "test2.js");
+      await writeFile(testFile1, "// Test file 1\nconst a = 1;");
+      await writeFile(testFile2, "// Test file 2\nconst b = 2;");
+
+      const mockContext = {
+        agents: {
+          generateStructureWithoutTools: "mock-agent-without-tools",
+        },
+        invoke: async (_agent, params) => {
+          expect(params.files.length).toBe(2);
+          expect(params.allFilesPaths).toContain("test1.js");
+          expect(params.allFilesPaths).toContain("test2.js");
+
+          return {
+            documentStructure: [
+              { title: "Doc 1", path: "/doc1" },
+              { title: "Doc 2", path: "/doc2" },
+            ],
+          };
+        },
+      };
+
+      const result = await generateSubStructure(
+        {
+          parentDocument: { title: "Parent", path: "/parent" },
+          subSourcePaths: [
+            { path: testFile1, reason: "First test" },
+            { path: testFile2, reason: "Second test" },
+          ],
+        },
+        { context: mockContext },
+      );
+
+      expect(result.subStructure.length).toBe(2);
+    });
+
+    test("should use generateStructure agent for large context", async () => {
+      const largeContent = `// Large file\n${"const x = 1;\n".repeat(150000)}`;
+      const testFile = join(testDir, "large.js");
+      await writeFile(testFile, largeContent);
+
+      const mockContext = {
+        agents: {
+          generateStructure: "mock-agent-with-tools",
+          generateStructureWithoutTools: "mock-agent-without-tools",
+        },
+        invoke: async (agent, params) => {
+          expect(agent).toBe("mock-agent-with-tools");
+          expect(params.isLargeContext).toBe(true);
+
+          return {
+            documentStructure: [{ title: "Large Doc", path: "/large" }],
+          };
+        },
+      };
+
+      const result = await generateSubStructure(
+        {
+          parentDocument: { title: "Parent", path: "/parent" },
+          subSourcePaths: [{ path: testFile, reason: "Large file" }],
+        },
+        { context: mockContext },
+      );
+
+      expect(result.subStructure).toBeDefined();
+      expect(result.subStructure.length).toBe(1);
+    });
+
+    test("should handle custom include and exclude patterns", async () => {
+      const srcDir = join(testDir, "src");
+      await mkdir(srcDir, { recursive: true });
+      await writeFile(join(srcDir, "index.js"), "// index");
+      await writeFile(join(srcDir, "test.spec.js"), "// test");
+      await writeFile(join(srcDir, "utils.ts"), "// utils");
+
+      const mockContext = {
+        agents: {
+          generateStructureWithoutTools: "mock-agent",
+        },
+        invoke: async (_agent, params) => {
+          const hasTestFile = params.files.some((f) => f.includes("test.spec.js"));
+          expect(hasTestFile).toBe(false);
+
+          return { documentStructure: [] };
+        },
+      };
+
+      await generateSubStructure(
+        {
+          parentDocument: { title: "Parent", path: "/parent" },
+          subSourcePaths: [{ path: testDir, reason: "Test directory" }],
+          includePatterns: ["**/*.js", "**/*.ts"],
+          excludePatterns: ["**/*.spec.js"],
+        },
+        { context: mockContext },
+      );
+    });
+
+    test("should deduplicate files in result", async () => {
+      const testFile = join(testDir, "test.js");
+      await writeFile(testFile, "// test");
+
+      const mockContext = {
+        agents: {
+          generateStructureWithoutTools: "mock-agent",
+        },
+        invoke: async (_agent, params) => {
+          const uniqueFiles = new Set(params.files);
+          expect(uniqueFiles.size).toBe(params.files.length);
+
+          return { documentStructure: [] };
+        },
+      };
+
+      await generateSubStructure(
+        {
+          parentDocument: { title: "Parent", path: "/parent" },
+          subSourcePaths: [
+            { path: testFile, reason: "First" },
+            { path: testFile, reason: "Second" },
+          ],
+        },
+        { context: mockContext },
+      );
+    });
+
+    test("should pass extra parameters to agent", async () => {
+      const testFile = join(testDir, "test.js");
+      await writeFile(testFile, "// test");
+
+      const mockContext = {
+        agents: {
+          generateStructureWithoutTools: "mock-agent",
+        },
+        invoke: async (_agent, params) => {
+          expect(params.extraParam1).toBe("value1");
+          expect(params.extraParam2).toBe("value2");
+
+          return { documentStructure: [] };
+        },
+      };
+
+      await generateSubStructure(
+        {
+          parentDocument: { title: "Parent", path: "/parent" },
+          subSourcePaths: [{ path: testFile, reason: "Test" }],
+          extraParam1: "value1",
+          extraParam2: "value2",
+        },
+        { context: mockContext },
+      );
+    });
+
+    test("should handle empty documentStructure from agent", async () => {
+      const testFile = join(testDir, "test.js");
+      await writeFile(testFile, "// test");
+
+      const mockContext = {
+        agents: {
+          generateStructureWithoutTools: "mock-agent",
+        },
+        invoke: async () => {
+          return {};
+        },
+      };
+
+      const result = await generateSubStructure(
+        {
+          parentDocument: { title: "Parent", path: "/parent" },
+          subSourcePaths: [{ path: testFile, reason: "Test" }],
+        },
+        { context: mockContext },
+      );
+
+      expect(result.subStructure).toEqual([]);
+    });
+  });
+});

package/tests/agents/init/init.test.mjs

@@ -986,13 +986,13 @@ describe("init", () => {
         const mockResponses = {
           checkbox_1: ["getStarted", "findAnswers"], // Document purpose
           checkbox_2: ["developers"], // Target audience
-          input_3: "Custom rules for documentation", // Custom rules
-          select_4: "domainFamiliar", // Reader knowledge level
-          select_5: "balancedCoverage", // Documentation depth
-          select_6: "en", // Primary language
-          checkbox_7: ["zh", "ja"], // Translation languages
-          input_8: join(tempDir, "docs"), // Documentation directory
+          select_3: "domainFamiliar", // Reader knowledge level
+          select_4: "balancedCoverage", // Documentation depth
+          select_5: "en", // Primary language
+          checkbox_6: ["zh", "ja"], // Translation languages
+          input_7: join(tempDir, "docs"), // Documentation directory
           search: "", // Source paths (empty to finish)
+          input_9: "Custom rules for documentation", // Custom rules (last step)
         };
 
         const mockPrompts = createMockPrompts(mockResponses);
@@ -1044,13 +1044,13 @@ describe("init", () => {
           checkbox_1: ["mixedPurpose"], // Document purpose - triggers follow-up
           checkbox: ["completeTasks", "findAnswers"], // Top priorities after mixedPurpose
           checkbox_2: ["developers", "devops"], // Target audience
-          input_3: "Custom rules for documentation", // Custom rules
-          select_4: "experiencedUsers", // Reader knowledge level
-          select_5: "comprehensive", // Documentation depth
-          select_6: "zh-CN", // Primary language
-          checkbox_7: ["en"], // Translation languages
-          input_8: join(tempDir, "documentation"), // Documentation directory
+          select_3: "experiencedUsers", // Reader knowledge level
+          select_4: "comprehensive", // Documentation depth
+          select_5: "zh-CN", // Primary language
+          checkbox_6: ["en"], // Translation languages
+          input_7: join(tempDir, "documentation"), // Documentation directory
           search: "", // Source paths (empty to finish)
+          input_9: "Custom rules for documentation", // Custom rules (last step)
         };
 
         const mockPrompts = createMockPrompts(mockResponses);
@@ -1091,13 +1091,13 @@ describe("init", () => {
         const mockResponses = {
           checkbox_1: ["getStarted"], // Document purpose
           checkbox_2: ["endUsers"], // Target audience
-          input_3: "Custom rules for documentation", // Custom rules
-          select_4: "completeBeginners", // Reader knowledge level
-          select_5: "essentialOnly", // Documentation depth
-          select_6: "en", // Primary language
-          checkbox_7: [], // No translation languages
-          input_8: join(tempDir, "simple-docs"), // Documentation directory
+          select_3: "completeBeginners", // Reader knowledge level
+          select_4: "essentialOnly", // Documentation depth
+          select_5: "en", // Primary language
+          checkbox_6: [], // No translation languages
+          input_7: join(tempDir, "simple-docs"), // Documentation directory
           search: "", // Source paths (empty to finish)
+          input_9: "Custom rules for documentation", // Custom rules (last step)
         };
 
         const mockPrompts = createMockPrompts(mockResponses);

package/tests/agents/publish/publish-docs.test.mjs

@@ -22,6 +22,12 @@ const mockPublishDocs = {
   publishDocs: mock(() => Promise.resolve({ success: true, boardId: "new-board-id" })),
 };
 
+const mockBrokerClient = {
+  checkCacheSession: mock(() => Promise.resolve({ sessionId: null, paymentLink: null })),
+};
+
+const mockBrokerClientConstructor = mock(() => mockBrokerClient);
+
 const mockChalk = {
   bold: mock((text) => text),
   cyan: mock((text) => text),
@@ -47,6 +53,7 @@ describe("publish-docs", () => {
 
   // Spies for internal utils
   let getAccessTokenSpy;
+  let getOfficialAccessTokenSpy;
   let beforePublishHookSpy;
   let ensureTmpDirSpy;
   let getGithubRepoUrlSpy;
@@ -57,6 +64,9 @@ describe("publish-docs", () => {
   beforeAll(() => {
     // Apply mocks for external dependencies only
     mock.module("@aigne/publish-docs", () => mockPublishDocs);
+    mock.module("@blocklet/payment-broker-client/node", () => ({
+      BrokerClient: mockBrokerClientConstructor,
+    }));
     mock.module("chalk", () => ({ default: mockChalk }));
     mock.module("fs-extra", () => ({ default: mockFsExtra }));
     mock.module("node:path", () => mockPath);
@@ -91,8 +101,19 @@ describe("publish-docs", () => {
     mockChalk.cyan.mockClear();
     mockChalk.cyan.mockImplementation((text) => text);
 
+    // Reset BrokerClient mock
+    mockBrokerClientConstructor.mockClear();
+    mockBrokerClientConstructor.mockImplementation(() => mockBrokerClient);
+    mockBrokerClient.checkCacheSession.mockClear();
+    mockBrokerClient.checkCacheSession.mockImplementation(() =>
+      Promise.resolve({ sessionId: null, paymentLink: null }),
+    );
+
     // Set up spies for internal utils
     getAccessTokenSpy = spyOn(authUtils, "getAccessToken").mockResolvedValue("mock-token");
+    getOfficialAccessTokenSpy = spyOn(authUtils, "getOfficialAccessToken").mockResolvedValue(
+      "official-mock-token",
+    );
     beforePublishHookSpy = spyOn(d2Utils, "beforePublishHook").mockResolvedValue();
     ensureTmpDirSpy = spyOn(d2Utils, "ensureTmpDir").mockResolvedValue();
     getGithubRepoUrlSpy = spyOn(utils, "getGithubRepoUrl").mockReturnValue(
@@ -126,6 +147,7 @@ describe("publish-docs", () => {
 
     // Restore all spies
     getAccessTokenSpy?.mockRestore();
+    getOfficialAccessTokenSpy?.mockRestore();
     beforePublishHookSpy?.mockRestore();
     ensureTmpDirSpy?.mockRestore();
     getGithubRepoUrlSpy?.mockRestore();
@@ -425,6 +447,55 @@ describe("publish-docs", () => {
   });
 
   // ERROR HANDLING TESTS
+  test("should handle failed official access token (null)", async () => {
+    loadConfigFromFileSpy.mockResolvedValue({});
+    getOfficialAccessTokenSpy.mockResolvedValue(null);
+    mockOptions.prompts.select.mockResolvedValue("default");
+
+    const result = await publishDocs(
+      {
+        docsDir: "./docs",
+        appUrl: "https://docsmith.aigne.io",
+      },
+      mockOptions,
+    );
+
+    expect(result.message).toBe("❌ Failed to publish docs: Failed to get official access token");
+  });
+
+  test("should handle failed official access token (undefined)", async () => {
+    loadConfigFromFileSpy.mockResolvedValue({});
+    getOfficialAccessTokenSpy.mockResolvedValue(undefined);
+    mockOptions.prompts.select.mockResolvedValue("default");
+
+    const result = await publishDocs(
+      {
+        docsDir: "./docs",
+        appUrl: "https://docsmith.aigne.io",
+      },
+      mockOptions,
+    );
+
+    expect(result.message).toBe("❌ Failed to publish docs: Failed to get official access token");
+  });
+
+  test("should handle checkCacheSession failure", async () => {
+    loadConfigFromFileSpy.mockResolvedValue({});
+    getOfficialAccessTokenSpy.mockResolvedValue("valid-token");
+    mockBrokerClient.checkCacheSession.mockRejectedValue(new Error("Cache session failed"));
+    mockOptions.prompts.select.mockResolvedValue("default");
+
+    const result = await publishDocs(
+      {
+        docsDir: "./docs",
+        appUrl: "https://docsmith.aigne.io",
+      },
+      mockOptions,
+    );
+
+    expect(result.message).toBe("❌ Failed to publish docs: Cache session failed");
+  });
+
   test("should handle publish failure", async () => {
     mockPublishDocs.publishDocs.mockRejectedValue(new Error("Publish failed"));
 
@@ -605,6 +676,10 @@ describe("publish-docs", () => {
     loadConfigFromFileSpy.mockResolvedValue({
       checkoutId: "cached-checkout-123",
     });
+    mockBrokerClient.checkCacheSession.mockResolvedValue({
+      sessionId: "cached-checkout-123",
+      paymentLink: "https://payment.example.com",
+    });
     mockOptions.prompts.select.mockResolvedValue("default");
 
     await publishDocs(
@@ -673,6 +748,10 @@ describe("publish-docs", () => {
       checkoutId: "cached-checkout-123",
       paymentUrl: "https://payment.example.com",
     });
+    mockBrokerClient.checkCacheSession.mockResolvedValue({
+      sessionId: "cached-checkout-123",
+      paymentLink: "https://payment.example.com",
+    });
     mockOptions.prompts.select.mockResolvedValue("new-instance-continue");
 
     const consoleSpy = spyOn(console, "log").mockImplementation(() => {});