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

package/tests/agents/utils/format-document-structure.test.mjs

@@ -1,364 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { stringify } from "yaml";
-import formatDocumentStructure from "../../../agents/utils/format-document-structure.mjs";
-
-describe("format-document-structure", () => {
-  // EDGE CASE TESTS
-  test("should handle when both documentStructure and originalDocumentStructure are null", async () => {
-    const result = await formatDocumentStructure({
-      documentStructure: null,
-      originalDocumentStructure: null,
-    });
-
-    expect(result).toEqual({
-      documentStructureYaml: "",
-      documentStructure: [],
-    });
-  });
-
-  test("should handle when both documentStructure and originalDocumentStructure are undefined", async () => {
-    const result = await formatDocumentStructure({
-      documentStructure: undefined,
-      originalDocumentStructure: undefined,
-    });
-
-    expect(result).toEqual({
-      documentStructureYaml: "",
-      documentStructure: [],
-    });
-  });
-
-  test("should handle when both parameters are missing", async () => {
-    const result = await formatDocumentStructure({});
-
-    expect(result).toEqual({
-      documentStructureYaml: "",
-      documentStructure: [],
-    });
-  });
-
-  test("should use originalDocumentStructure when documentStructure is null", async () => {
-    const originalDocumentStructure = [
-      {
-        title: "Original Document",
-        path: "/original",
-        parentId: null,
-        description: "From original structure",
-        extraField: "should be filtered out",
-      },
-    ];
-
-    const result = await formatDocumentStructure({
-      documentStructure: null,
-      originalDocumentStructure,
-    });
-
-    const expectedData = [
-      {
-        title: "Original Document",
-        path: "/original",
-        parentId: null,
-        description: "From original structure",
-      },
-    ];
-    const expectedYaml = stringify(expectedData, {
-      indent: 2,
-      lineWidth: 120,
-      minContentWidth: 20,
-    });
-
-    expect(result.documentStructureYaml).toBe(expectedYaml);
-    expect(result.documentStructure).toBe(null);
-  });
-
-  test("should use originalDocumentStructure when documentStructure is undefined", async () => {
-    const originalDocumentStructure = [
-      {
-        title: "Fallback Document",
-        path: "/fallback",
-        parentId: "parent-id",
-        description: "Fallback to original",
-      },
-    ];
-
-    const result = await formatDocumentStructure({
-      originalDocumentStructure,
-    });
-
-    const expectedData = [
-      {
-        title: "Fallback Document",
-        path: "/fallback",
-        parentId: "parent-id",
-        description: "Fallback to original",
-      },
-    ];
-    const expectedYaml = stringify(expectedData, {
-      indent: 2,
-      lineWidth: 120,
-      minContentWidth: 20,
-    });
-
-    expect(result.documentStructureYaml).toBe(expectedYaml);
-    expect(result.documentStructure).toBe(undefined);
-  });
-
-  // BASIC FUNCTIONALITY TESTS
-  test("should format empty documentation structure", async () => {
-    const result = await formatDocumentStructure({
-      documentStructure: [],
-    });
-
-    const expectedYaml = stringify([], {
-      indent: 2,
-      lineWidth: 120,
-      minContentWidth: 20,
-    });
-
-    expect(result).toEqual({
-      documentStructureYaml: expectedYaml,
-      documentStructure: [],
-    });
-  });
-
-  test("should format single item documentation structure", async () => {
-    const documentStructure = [
-      {
-        title: "Getting Started",
-        path: "/getting-started",
-        parentId: null,
-        description: "Introduction to the platform",
-        extraField: "should be ignored",
-      },
-    ];
-
-    const result = await formatDocumentStructure({ documentStructure });
-
-    const expectedData = [
-      {
-        title: "Getting Started",
-        path: "/getting-started",
-        parentId: null,
-        description: "Introduction to the platform",
-      },
-    ];
-    const expectedYaml = stringify(expectedData, {
-      indent: 2,
-      lineWidth: 120,
-      minContentWidth: 20,
-    });
-
-    expect(result.documentStructure).toEqual(documentStructure);
-    expect(result.documentStructureYaml).toBe(expectedYaml);
-  });
-
-  test("should format multiple items documentation structure", async () => {
-    const documentStructure = [
-      {
-        title: "API Reference",
-        path: "/api",
-        parentId: null,
-        description: "Complete API documentation",
-      },
-      {
-        title: "Authentication",
-        path: "/api/auth",
-        parentId: "/api",
-        description: "Authentication endpoints",
-      },
-      {
-        title: "Users",
-        path: "/api/users",
-        parentId: "/api",
-        description: "User management endpoints",
-      },
-    ];
-
-    const result = await formatDocumentStructure({ documentStructure });
-
-    const expectedData = [
-      {
-        title: "API Reference",
-        path: "/api",
-        parentId: null,
-        description: "Complete API documentation",
-      },
-      {
-        title: "Authentication",
-        path: "/api/auth",
-        parentId: "/api",
-        description: "Authentication endpoints",
-      },
-      {
-        title: "Users",
-        path: "/api/users",
-        parentId: "/api",
-        description: "User management endpoints",
-      },
-    ];
-    const expectedYaml = stringify(expectedData, {
-      indent: 2,
-      lineWidth: 120,
-      minContentWidth: 20,
-    });
-
-    expect(result.documentStructure).toEqual(documentStructure);
-    expect(result.documentStructureYaml).toBe(expectedYaml);
-  });
-
-  // FIELD EXTRACTION TESTS
-  test("should extract only required fields", async () => {
-    const documentStructure = [
-      {
-        title: "Test Document",
-        path: "/test",
-        parentId: "parent-123",
-        description: "Test description",
-        // Extra fields that should be filtered out
-        id: "doc-123",
-        content: "Document content",
-        metadata: { tags: ["test"] },
-        lastModified: "2024-01-01",
-        author: "John Doe",
-      },
-    ];
-
-    const result = await formatDocumentStructure({ documentStructure });
-
-    const expectedData = [
-      {
-        title: "Test Document",
-        path: "/test",
-        parentId: "parent-123",
-        description: "Test description",
-      },
-    ];
-    const expectedYaml = stringify(expectedData, {
-      indent: 2,
-      lineWidth: 120,
-      minContentWidth: 20,
-    });
-
-    expect(result.documentStructureYaml).toBe(expectedYaml);
-    // Verify extra fields are not in the YAML output
-    expect(result.documentStructureYaml).not.toContain("doc-123");
-    expect(result.documentStructureYaml).not.toContain("Document content");
-    expect(result.documentStructureYaml).not.toContain("John Doe");
-  });
-
-  test("should handle items with missing optional fields", async () => {
-    const documentStructure = [
-      {
-        title: "Required Title",
-        path: "/required-path",
-        // parentId and description are missing
-      },
-    ];
-
-    const result = await formatDocumentStructure({ documentStructure });
-
-    const expectedData = [
-      {
-        title: "Required Title",
-        path: "/required-path",
-        parentId: undefined,
-        description: undefined,
-      },
-    ];
-    const expectedYaml = stringify(expectedData, {
-      indent: 2,
-      lineWidth: 120,
-      minContentWidth: 20,
-    });
-
-    expect(result.documentStructureYaml).toBe(expectedYaml);
-  });
-
-  test("should preserve null and undefined values", async () => {
-    const documentStructure = [
-      {
-        title: "Test Item",
-        path: "/test",
-        parentId: null,
-        description: undefined,
-      },
-    ];
-
-    const result = await formatDocumentStructure({ documentStructure });
-
-    const expectedData = [
-      {
-        title: "Test Item",
-        path: "/test",
-        parentId: null,
-        description: undefined,
-      },
-    ];
-    const expectedYaml = stringify(expectedData, {
-      indent: 2,
-      lineWidth: 120,
-      minContentWidth: 20,
-    });
-
-    expect(result.documentStructureYaml).toBe(expectedYaml);
-  });
-
-  test("should handle items with special characters", async () => {
-    const documentStructure = [
-      {
-        title: "Special Characters: @#$%^&*()",
-        path: "/special-chars-test",
-        parentId: null,
-        description: 'Testing with 中文, émojis 🚀, and "quotes"',
-      },
-    ];
-
-    const result = await formatDocumentStructure({ documentStructure });
-
-    // Since YAML is mocked, just verify the function runs without error
-    // and returns a structure with the expected properties
-    expect(result.documentStructureYaml).toBeDefined();
-    expect(result.documentStructure).toEqual(documentStructure);
-  });
-
-  test("should return both yaml string and original documentation structure", async () => {
-    const documentStructure = [
-      {
-        title: "Return Test",
-        path: "/return-test",
-        parentId: null,
-        description: "Testing return values",
-      },
-    ];
-
-    const result = await formatDocumentStructure({ documentStructure });
-
-    expect(result).toHaveProperty("documentStructureYaml");
-    expect(result).toHaveProperty("documentStructure");
-    expect(typeof result.documentStructureYaml).toBe("string");
-    expect(result.documentStructure).toBe(documentStructure); // Should be the same reference
-  });
-
-  test("should preserve original documentation structure unchanged", async () => {
-    const originalDocumentStructure = [
-      {
-        title: "Original",
-        path: "/original",
-        parentId: null,
-        description: "Original description",
-        extraField: "should remain",
-      },
-    ];
-
-    const result = await formatDocumentStructure({
-      documentStructure: originalDocumentStructure,
-    });
-
-    // Original should be unchanged
-    expect(originalDocumentStructure[0]).toHaveProperty("extraField");
-    expect(originalDocumentStructure[0].extraField).toBe("should remain");
-
-    // Return value should reference the same object
-    expect(result.documentStructure).toBe(originalDocumentStructure);
-  });
-});

package/tests/agents/utils/fs.test.mjs

@@ -1,267 +0,0 @@
-import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import * as fsPromises from "node:fs/promises";
-import * as path from "node:path";
-import fs from "../../../agents/utils/fs.mjs";
-
-describe("fs utility", () => {
-  let readFileSpy;
-  let writeFileSpy;
-  let mkdirSpy;
-  let rmSpy;
-  let readdirSpy;
-  let joinSpy;
-  let dirnameSpy;
-
-  beforeEach(() => {
-    // Spy on fs/promises methods
-    readFileSpy = spyOn(fsPromises, "readFile").mockResolvedValue("mocked file content");
-    writeFileSpy = spyOn(fsPromises, "writeFile").mockResolvedValue();
-    mkdirSpy = spyOn(fsPromises, "mkdir").mockResolvedValue();
-    rmSpy = spyOn(fsPromises, "rm").mockResolvedValue();
-    readdirSpy = spyOn(fsPromises, "readdir").mockResolvedValue([
-      { name: "file1.txt", parentPath: "/test/root", isDirectory: () => false },
-      { name: "subdir", parentPath: "/test/root", isDirectory: () => true },
-    ]);
-
-    // Spy on path methods
-    joinSpy = spyOn(path, "join").mockImplementation((...paths) => paths.join("/"));
-    dirnameSpy = spyOn(path, "dirname").mockImplementation(
-      (path) => path.split("/").slice(0, -1).join("/") || "/",
-    );
-  });
-
-  afterEach(() => {
-    // Restore all spies
-    readFileSpy?.mockRestore();
-    writeFileSpy?.mockRestore();
-    mkdirSpy?.mockRestore();
-    rmSpy?.mockRestore();
-    readdirSpy?.mockRestore();
-    joinSpy?.mockRestore();
-    dirnameSpy?.mockRestore();
-  });
-
-  // ERROR HANDLING TESTS
-  test("should throw error when rootDir is not specified", async () => {
-    await expect(
-      fs({
-        action: "read_file",
-        path: "test.txt",
-      }),
-    ).rejects.toThrow("Root directory is not specified");
-  });
-
-  test("should throw error when rootDir is empty string", async () => {
-    await expect(
-      fs({
-        rootDir: "",
-        action: "read_file",
-        path: "test.txt",
-      }),
-    ).rejects.toThrow("Root directory is not specified");
-  });
-
-  // READ_FILE ACTION TESTS
-  test("should read file successfully", async () => {
-    readFileSpy.mockResolvedValue("test file content");
-
-    const result = await fs({
-      rootDir: "/test/root",
-      action: "read_file",
-      path: "test.txt",
-    });
-
-    expect(joinSpy).toHaveBeenCalledWith("/test/root", "test.txt");
-    expect(readFileSpy).toHaveBeenCalledWith("/test/root/test.txt", "utf-8");
-    expect(result).toEqual({
-      status: "ok",
-      path: "/test/root/test.txt",
-      content: "test file content",
-    });
-  });
-
-  test("should handle read file with nested path", async () => {
-    await fs({
-      rootDir: "/project",
-      action: "read_file",
-      path: "src/components/Button.tsx",
-    });
-
-    expect(joinSpy).toHaveBeenCalledWith("/project", "src/components/Button.tsx");
-    expect(readFileSpy).toHaveBeenCalledWith("/project/src/components/Button.tsx", "utf-8");
-  });
-
-  // WRITE_FILE ACTION TESTS
-  test("should write file successfully", async () => {
-    const result = await fs({
-      rootDir: "/test/root",
-      action: "write_file",
-      path: "output.txt",
-      content: "Hello, world!",
-    });
-
-    expect(dirnameSpy).toHaveBeenCalledWith("/test/root/output.txt");
-    expect(mkdirSpy).toHaveBeenCalledWith("/test/root", { recursive: true });
-    expect(writeFileSpy).toHaveBeenCalledWith("/test/root/output.txt", "Hello, world!");
-    expect(result).toEqual({
-      status: "ok",
-      path: "/test/root/output.txt",
-      content: "Hello, world!",
-    });
-  });
-
-  test("should write file with empty content when content is not provided", async () => {
-    const result = await fs({
-      rootDir: "/test/root",
-      action: "write_file",
-      path: "empty.txt",
-    });
-
-    expect(writeFileSpy).toHaveBeenCalledWith("/test/root/empty.txt", "");
-    expect(result.content).toBeUndefined(); // The function returns the original content parameter
-  });
-
-  test("should create directories recursively when writing file", async () => {
-    dirnameSpy.mockReturnValue("/test/root/deep/nested");
-
-    await fs({
-      rootDir: "/test/root",
-      action: "write_file",
-      path: "deep/nested/file.txt",
-      content: "nested content",
-    });
-
-    expect(mkdirSpy).toHaveBeenCalledWith("/test/root/deep/nested", {
-      recursive: true,
-    });
-  });
-
-  // DELETE_FILE ACTION TESTS
-  test("should delete file successfully", async () => {
-    const result = await fs({
-      rootDir: "/test/root",
-      action: "delete_file",
-      path: "to-delete.txt",
-    });
-
-    expect(joinSpy).toHaveBeenCalledWith("/test/root", "to-delete.txt");
-    expect(rmSpy).toHaveBeenCalledWith("/test/root/to-delete.txt", {
-      recursive: true,
-      force: true,
-    });
-    expect(result).toEqual({
-      status: "ok",
-      path: "/test/root/to-delete.txt",
-    });
-  });
-
-  test("should delete directory recursively", async () => {
-    await fs({
-      rootDir: "/project",
-      action: "delete_file",
-      path: "build",
-    });
-
-    expect(rmSpy).toHaveBeenCalledWith("/project/build", {
-      recursive: true,
-      force: true,
-    });
-  });
-
-  // LIST_DIRECTORY ACTION TESTS
-  test("should list directory entries successfully", async () => {
-    const result = await fs({
-      rootDir: "/test/root",
-      action: "list_directory",
-      path: "src",
-    });
-
-    expect(joinSpy).toHaveBeenCalledWith("/test/root", "src");
-    expect(readdirSpy).toHaveBeenCalledWith("/test/root/src", { withFileTypes: true });
-    expect(result).toEqual({
-      status: "ok",
-      entries: [
-        { path: "/test/root/file1.txt", isDirectory: false },
-        { path: "/test/root/subdir", isDirectory: true },
-      ],
-    });
-  });
-
-  test("should handle empty directory listing", async () => {
-    readdirSpy.mockResolvedValue([]);
-
-    const result = await fs({
-      rootDir: "/test/root",
-      action: "list_directory",
-      path: "empty-dir",
-    });
-
-    expect(result.entries).toEqual([]);
-  });
-
-  // PATH HANDLING TESTS
-  test("should handle root directory with trailing slash", async () => {
-    await fs({
-      rootDir: "/test/root/",
-      action: "read_file",
-      path: "file.txt",
-    });
-
-    expect(joinSpy).toHaveBeenCalledWith("/test/root/", "file.txt");
-  });
-
-  test("should handle path with leading slash", async () => {
-    await fs({
-      rootDir: "/test/root",
-      action: "read_file",
-      path: "/absolute/path.txt",
-    });
-
-    expect(joinSpy).toHaveBeenCalledWith("/test/root", "/absolute/path.txt");
-  });
-
-  test("should handle complex nested paths", async () => {
-    await fs({
-      rootDir: "/project",
-      action: "write_file",
-      path: "src/components/ui/Button/index.tsx",
-      content: "export default Button;",
-    });
-
-    expect(joinSpy).toHaveBeenCalledWith("/project", "src/components/ui/Button/index.tsx");
-  });
-
-  // UNDEFINED ACTION TEST
-  test("should return undefined for unknown action", async () => {
-    const result = await fs({
-      rootDir: "/test/root",
-      action: "unknown_action",
-      path: "test.txt",
-    });
-
-    expect(result).toBeUndefined();
-  });
-
-  // EDGE CASES
-  test("should handle special characters in paths", async () => {
-    await fs({
-      rootDir: "/test/root",
-      action: "read_file",
-      path: "文件名 with spaces & symbols!.txt",
-    });
-
-    expect(joinSpy).toHaveBeenCalledWith("/test/root", "文件名 with spaces & symbols!.txt");
-  });
-
-  test("should handle null content for write_file", async () => {
-    const result = await fs({
-      rootDir: "/test/root",
-      action: "write_file",
-      path: "null-content.txt",
-      content: null,
-    });
-
-    expect(writeFileSpy).toHaveBeenCalledWith("/test/root/null-content.txt", "");
-    expect(result.content).toBe(null);
-  });
-});