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

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

@@ -1,45 +0,0 @@
-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("checkDocumentStructure 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/check-document-structure.yaml"),
-      {
-        model: loadModel,
-      },
-    );
-
-    expect(agent).toBeDefined();
-
-    // Verify agent exists and is correct type
-    expect(agent).toBeDefined();
-    expect(agent).toBeInstanceOf(AIAgent);
-  });
-
-  test("should have instructions loaded from file", async () => {
-    const agent = await loadAgent(
-      join(import.meta.dirname, "../../../agents/generate/check-document-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();
-  });
-});

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

@@ -1,279 +0,0 @@
-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(() => {
-    // Set test environment variable
-    process.env.NODE_ENV = "test";
-
-    // Reset all mocks
-    mock.restore();
-
-    originalDocumentStructure = [
-      { path: "/getting-started", title: "Getting Started" },
-      { path: "/api", title: "API Reference" },
-    ];
-
-    mockOptions = {
-      prompts: {
-        input: mock(async () => ""),
-        select: mock(async () => "generate"),
-      },
-      context: {
-        agents: {
-          generateStructure: {},
-          generateStructureWithoutTools: {},
-        },
-        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(() => {
-    // Clean up environment variable
-    delete process.env.NODE_ENV;
-
-    // Restore all spies
-    accessSpy?.mockRestore();
-    getActiveRulesForScopeSpy?.mockRestore();
-    getCurrentGitHeadSpy?.mockRestore();
-    hasFileChangesBetweenCommitsSpy?.mockRestore();
-    getProjectInfoSpy?.mockRestore();
-    loadConfigFromFileSpy?.mockRestore();
-    saveValueToConfigSpy?.mockRestore();
-  });
-
-  test("should return original documentation 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 return original structure when it exists and no force regenerate", async () => {
-    const result = await checkNeedGenerateStructure(
-      { originalDocumentStructure, docsDir: "./docs" },
-      mockOptions,
-    );
-
-    expect(mockOptions.prompts.input).not.toHaveBeenCalled();
-    expect(mockOptions.context.invoke).not.toHaveBeenCalled();
-    expect(result.documentStructure).toEqual(originalDocumentStructure);
-  });
-
-  test("should handle empty user feedback input", async () => {
-    mockOptions.prompts.input.mockImplementation(async () => "   ");
-
-    const result = await checkNeedGenerateStructure(
-      { originalDocumentStructure, 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 when generating", async () => {
-    const mockRules = [{ rule: "Structure rule 1" }];
-    getActiveRulesForScopeSpy.mockImplementation(() => mockRules);
-
-    await checkNeedGenerateStructure(
-      { originalDocumentStructure, forceRegenerate: true, 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, forceRegenerate: true, 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, forceRegenerate: true, 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 when regenerating", async () => {
-    const result = await checkNeedGenerateStructure(
-      {
-        originalDocumentStructure,
-        forceRegenerate: true,
-        feedback: "some feedback",
-        docsDir: "./docs",
-      },
-      mockOptions,
-    );
-
-    expect(result.feedback).toBe("");
-  });
-
-  test("should pass through additional parameters when regenerating", async () => {
-    const additionalParams = {
-      customParam1: "value1",
-      customParam2: "value2",
-    };
-
-    await checkNeedGenerateStructure(
-      {
-        originalDocumentStructure,
-        forceRegenerate: true,
-        docsDir: "./docs",
-        ...additionalParams,
-      },
-      mockOptions,
-    );
-
-    expect(mockOptions.context.invoke).toHaveBeenCalledWith(
-      mockOptions.context.agents.generateStructureWithoutTools,
-      expect.objectContaining(additionalParams),
-    );
-  });
-
-  test("should return userDeferred when user selects 'later' and no originalDocumentStructure exists", async () => {
-    mockOptions.prompts.select.mockImplementation(async () => "later");
-
-    const result = await checkNeedGenerateStructure({ docsDir: "./docs" }, mockOptions);
-
-    expect(result).toBeDefined();
-    expect(result.userDeferred).toBe(true);
-    expect(result.documentStructure).toBe(null);
-
-    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),
-    );
-  });
-});