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

package/tests/agents/evaluate/code-snippet.test.mjs

@@ -1,163 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import fs from "node:fs/promises";
-import path, { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import evaluateDocumentCode from "../../../agents/evaluate/code-snippet.mjs";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-describe("evaluateDocumentCode", () => {
-  test(
-    "should evaluate markdown document",
-    async () => {
-      const content = await fs.readFile(path.join(__dirname, "fixtures/js-sdk.md"), "utf-8");
-      const result = await evaluateDocumentCode({ content });
-
-      expect("codeEvaluation" in result).toEqual(true);
-      expect(result.codeEvaluation.baseline).toEqual(100);
-      expect("details" in result.codeEvaluation).toEqual(true);
-      expect(result.codeEvaluation.details.length).toEqual(0);
-      expect(result.codeEvaluation.totalCount).toEqual(3);
-      expect(result.codeEvaluation.errorCount).toEqual(0);
-      expect(result.codeEvaluation.ignoreCount).toEqual(0);
-    },
-    60 * 1000,
-  );
-
-  test(
-    "should evaluate markdown document with error",
-    async () => {
-      const content = await fs.readFile(path.join(__dirname, "fixtures/api-services.md"), "utf-8");
-      const result = await evaluateDocumentCode({ content });
-
-      expect(result.codeEvaluation.details.length).toEqual(2);
-      expect(result.codeEvaluation.totalCount).toEqual(1);
-      expect(result.codeEvaluation.errorCount).toEqual(1);
-      expect(result.codeEvaluation.ignoreCount).toEqual(1);
-    },
-    60 * 1000,
-  );
-
-  test(
-    "should handle linter failures with retry mechanism",
-    async () => {
-      // Since we can't easily mock ES modules, we'll mock the global fetch used by lintCode
-      const originalFetch = globalThis.fetch;
-      let callCount = 0;
-
-      // Mock fetch to simulate linter API failures
-      globalThis.fetch = async (_url, _options) => {
-        callCount++;
-        if (callCount <= 2) {
-          // Fail the first 2 attempts
-          throw new Error(`Network error ${callCount}`);
-        }
-        // Succeed on the third attempt with a valid response
-        return {
-          ok: true,
-          json: async () => ({
-            success: true,
-            issues: [],
-          }),
-        };
-      };
-
-      try {
-        // Create markdown content with code blocks that will trigger linting
-        const content = `
-# Test Document
-
-\`\`\`javascript
-console.log("test");
-\`\`\`
-        `;
-
-        const result = await evaluateDocumentCode({ content });
-
-        // Verify the function completed successfully despite initial failures
-        expect(result.codeEvaluation).toBeDefined();
-        expect(result.codeEvaluation.totalCount).toBe(1);
-
-        // With fetch mocking, if retries work, we should get a successful result
-        // The exact behavior depends on how the retries are handled
-      } finally {
-        // Restore the original fetch function
-        globalThis.fetch = originalFetch;
-      }
-    },
-    120 * 1000, // Longer timeout for retry testing
-  );
-
-  test(
-    "should handle persistent linter failures after retries",
-    async () => {
-      // Mock fetch to always fail
-      const originalFetch = globalThis.fetch;
-      let callCount = 0;
-
-      globalThis.fetch = async (_url, _options) => {
-        callCount++;
-        throw new Error(`Persistent network failure ${callCount}`);
-      };
-
-      try {
-        const content = `
-# Test Document
-
-\`\`\`javascript
-console.log("test");
-\`\`\`
-        `;
-
-        // Expect this to throw since all retries will fail
-        await expect(evaluateDocumentCode({ content })).rejects.toThrow("Linting failed:");
-
-        // Verify retries happened (should call 4 times total: 1 + 3 retries)
-        expect(callCount).toBe(4);
-      } finally {
-        // Restore the original fetch function
-        globalThis.fetch = originalFetch;
-      }
-    },
-    120 * 1000,
-  );
-
-  test("should demonstrate onFailedAttempt callback logic from lines 42-44", () => {
-    // Test that simulates the exact logic from the onFailedAttempt callback (lines 42-44)
-    // This verifies that the callback would format the debug message correctly
-
-    // Simulate the parameters that would be passed to onFailedAttempt
-    const mockFailedAttempt = {
-      error: new Error("Simulated linter failure"),
-      attemptNumber: 2,
-      retriesLeft: 1,
-    };
-
-    // Simulate the exact logic from lines 43-44 in the source code
-    const debugMessage = `Attempt ${mockFailedAttempt.attemptNumber} failed: ${mockFailedAttempt.error.message}. There are ${mockFailedAttempt.retriesLeft} retries left.`;
-
-    // Verify the message format matches what's expected from the source
-    const expectedMessage = "Attempt 2 failed: Simulated linter failure. There are 1 retries left.";
-    expect(debugMessage).toBe(expectedMessage);
-
-    // Verify the message format follows the pattern from lines 43-44
-    const messagePattern = /Attempt \d+ failed: .+\. There are \d+ retries left\./;
-    expect(debugMessage).toMatch(messagePattern);
-
-    // Test with different retry scenarios
-    const scenarios = [
-      { attemptNumber: 1, retriesLeft: 2, error: new Error("First failure") },
-      { attemptNumber: 3, retriesLeft: 0, error: new Error("Final attempt") },
-      { attemptNumber: 2, retriesLeft: 1, error: new Error("Network timeout") },
-    ];
-
-    scenarios.forEach((scenario) => {
-      const message = `Attempt ${scenario.attemptNumber} failed: ${scenario.error.message}. There are ${scenario.retriesLeft} retries left.`;
-      expect(message).toMatch(messagePattern);
-      expect(message).toContain(`Attempt ${scenario.attemptNumber} failed:`);
-      expect(message).toContain(`There are ${scenario.retriesLeft} retries left.`);
-    });
-  });
-});

package/tests/agents/evaluate/fixtures/api-services.md

@@ -1,87 +0,0 @@
-# Services
-
-The `@blocklet/js-sdk` is organized into several service classes, each responsible for a specific domain of functionality. These services act as dedicated clients for different Blocklet API endpoints, providing a structured and intuitive way to interact with the platform's features.
-
-Most core services are pre-initialized and available as properties on the main `BlockletSDK` instance, which you can obtain using the `getBlockletSDK()` function.
-
-```javascript Accessing a Service icon=logos:javascript
-import { getBlockletSDK } from '@blocklet/js-sdk';
-
-const sdk = getBlockletSDK();
-
-// Access the AuthService to get user info
-async function getUserProfile() {
-  const profile = await sdk.user.getProfile();
-  console.log(profile);
-}
-
-// Access the BlockletService to get blocklet info
-async function getBlockletMeta() {
-  const meta = await sdk.blocklet.getMeta();
-  console.log(meta);
-}
-```
-
-The diagram below illustrates the structure of the `BlockletSDK` instance and its relationship with the core services.
-
-```d2
-direction: down
-
-BlockletSDK: {
-  label: "BlockletSDK Instance"
-  shape: rectangle
-  
-  grid-columns: 3
-  grid-gap: 50
-
-  user: {
-    label: "user: AuthService"
-    shape: rectangle
-  }
-
-  blocklet: {
-    label: "blocklet: BlockletService"
-    shape: rectangle
-  }
-
-  userSession: {
-    label: "userSession: UserSessionService"
-    shape: rectangle
-  }
-
-  federated: {
-    label: "federated: FederatedService"
-    shape: rectangle
-  }
-
-  token: {
-    label: "token: TokenService"
-    shape: rectangle
-  }
-}
-```
-
-Below is a complete list of the available services. Click on any service to view its detailed API reference.
-
-<x-cards data-columns="2">
-  <x-card data-title="AuthService" data-href="/api/services/auth" data-icon="lucide:user-cog">
-    API for managing user profiles, privacy settings, notifications, and authentication actions like logout.
-  </x-card>
-  <x-card data-title="BlockletService" data-href="/api/services/blocklet" data-icon="lucide:box">
-    API for fetching and loading blocklet metadata from `window.blocklet` or a remote URL.
-  </x-card>
-  <x-card data-title="ComponentService" data-href="/api/services/component" data-icon="lucide:layout-template">
-    API for getting information about mounted components and constructing URLs for them.
-  </x-card>
-  <x-card data-title="FederatedService" data-href="/api/services/federated" data-icon="lucide:network">
-    API for interacting with Federated Login Group settings and retrieving information about master and current apps.
-  </x-card>
-  <x-card data-title="TokenService" data-href="/api/services/token" data-icon="lucide:key-round">
-    Low-level API for getting, setting, and removing session and refresh tokens from storage (Cookies and LocalStorage).
-  </x-card>
-  <x-card data-title="UserSessionService" data-href="/api/services/user-session" data-icon="lucide:users">
-    API for fetching and managing user login sessions.
-  </x-card>
-</x-cards>
-
-Each service provides a focused set of methods for a specific part of the Blocklet platform. To understand the data structures and types returned by these services, please see the [Types](./api-types.md) reference.

package/tests/agents/evaluate/fixtures/js-sdk.md

@@ -1,94 +0,0 @@
-# Getting Started
-
-This guide will walk you through the essential steps to install the `@blocklet/js-sdk` and make your first API call. Our goal is to get you up and running in just a few minutes.
-
-## Installation
-
-First, you need to add the SDK to your project. You can use your preferred package manager:
-
-```bash Installation icon=mdi:bash
-npm install @blocklet/js-sdk
-
-# or
-
-yarn add @blocklet/js-sdk
-
-# or
-
-pnpm add @blocklet/js-sdk
-```
-
-## Basic Usage
-
-The SDK is designed to be straightforward. The two most common use cases are accessing core Blocklet services (like user authentication) and making authenticated requests to your own Blocklet's backend.
-
-### Accessing Core Services
-
-The easiest way to use the SDK is by importing the `getBlockletSDK` singleton factory. This function ensures that you always get the same SDK instance throughout your application, simplifying state management.
-
-Here's how you can use it to fetch the current user's profile:
-
-```javascript Get User Profile icon=logos:javascript
-import { getBlockletSDK } from '@blocklet/js-sdk';
-
-const sdk = getBlockletSDK();
-
-async function fetchUserProfile() {
-  try {
-    const { data: userProfile } = await sdk.user.getProfile();
-    console.log('User Profile:', userProfile);
-  } catch (error) {
-    console.error('Failed to fetch user profile:', error);
-  }
-}
-
-fetchUserProfile();
-```
-
-The `sdk` instance provides access to various services like `user`, `userSession`, `blocklet`, and more. These services handle communication with the well-known Blocklet service endpoints for you.
-
-### Making API Requests to Your Blocklet
-
-For communicating with your own Blocklet's backend API, the SDK provides `createAxios` and `createFetch` helper functions. These are wrappers around Axios and the native Fetch API that come pre-configured with everything needed for authenticated requests.
-
-They automatically handle:
-- Setting the correct `baseURL` for your component.
-- Attaching the session token to the `Authorization` header.
-- Including the `x-csrf-token` for security.
-- Refreshing the session token automatically if it expires.
-
-Here’s how to create an API client for your backend using `createAxios`:
-
-```javascript Create an API Client icon=logos:javascript
-import { createAxios } from '@blocklet/js-sdk';
-
-// Create an Axios instance configured for your Blocklet
-const apiClient = createAxios();
-
-async function fetchData() {
-  try {
-    // Make a request to your own backend, e.g., GET /api/posts
-    const response = await apiClient.get('/api/posts');
-    console.log('Posts:', response.data);
-  } catch (error) {
-    console.error('Failed to fetch data:', error);
-  }
-}
-
-fetchData();
-```
-
-With this setup, you don't need to manually manage tokens or headers. The SDK takes care of the authentication flow seamlessly.
-
-## Next Steps
-
-You've now learned how to install the `@blocklet/js-sdk` and use it for the two most common scenarios. To dive deeper, we recommend exploring the following guides:
-
-<x-cards>
-  <x-card data-title="Making API Requests" data-icon="lucide:file-code-2" data-href="/guides/making-api-requests">
-    Learn more about advanced configuration for `createAxios` and `createFetch`, including error handling and request parameters.
-  </x-card>
-  <x-card data-title="Authentication" data-icon="lucide:key-round" data-href="/guides/authentication">
-    Understand how the SDK manages session and refresh tokens under the hood to keep your users logged in.
-  </x-card>
-</x-cards>

package/tests/agents/evaluate/generate-report.test.mjs

@@ -1,312 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { existsSync } from "node:fs";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import generateEvaluationReport from "../../../agents/evaluate/generate-report.mjs";
-
-describe("generateEvaluationReport", () => {
-  let testDir;
-
-  beforeAll(async () => {
-    process.env.OBSERVABILITY_DISABLED = "true";
-    // Create a temporary directory for testing
-    testDir = await mkdtemp(join(tmpdir(), "test-evaluation-report-"));
-  });
-
-  afterAll(async () => {
-    delete process.env.OBSERVABILITY_DISABLED;
-
-    // Clean up test files
-    try {
-      if (existsSync(testDir)) {
-        await rm(testDir, { recursive: true, force: true });
-      }
-    } catch (error) {
-      console.warn("Failed to clean up test files:", error.message);
-    }
-  });
-
-  test("should generate evaluation report with correct structure", async () => {
-    // Mock evaluation data matching the expected schema
-    const testData = {
-      structureEvaluation: {
-        purposeCoverage: {
-          score: 4,
-          reason: "Covers most main objectives, missing minor targets",
-          covered: ["Quick Start", "API Reference"],
-          missing: ["Troubleshooting"],
-        },
-        audienceCoverage: {
-          score: 5,
-          reason: "Covers all selected audiences",
-          covered: ["Developers", "DevOps Engineers"],
-          missing: [],
-        },
-        coverageDepthAlignment: {
-          score: 3,
-          reason: "About half of modules depth does not match expectations",
-        },
-      },
-      originalDocumentStructure: [
-        {
-          path: "/api/authentication",
-          title: "Authentication",
-          description: "Authentication guide",
-          parentId: null,
-          documentEvaluation: {
-            readability: {
-              score: 4,
-              reason: "Clear language with minor errors that don't affect reading",
-            },
-            coherence: { score: 5, reason: "Clear logic, no contradictions or jumps" },
-            contentQuality: { score: 3, reason: "50-70% implementation, some content is brief" },
-            translationQuality: { score: 4, reason: "Generally accurate with minor issues" },
-            consistency: { score: 4, reason: "Generally consistent with 1-2 differences" },
-            purposeAlignment: {
-              score: 4,
-              reason: "Generally meets objectives with minor irrelevant content",
-            },
-            audienceAlignment: { score: 5, reason: "Completely meets audience needs" },
-            knowledgeLevelAlignment: { score: 3, reason: "Partial match, about half doesn't fit" },
-          },
-          codeEvaluation: null,
-        },
-        {
-          path: "/api/endpoints",
-          title: "API Endpoints",
-          description: "API endpoints documentation",
-          parentId: null,
-          documentEvaluation: {
-            readability: { score: 5, reason: "No errors, natural and fluent language" },
-            coherence: {
-              score: 4,
-              reason: "Overall coherent with occasional unnatural transitions",
-            },
-            contentQuality: {
-              score: 4,
-              reason: "70-90% planning points implemented, minor details lacking",
-            },
-            translationQuality: {
-              score: 5,
-              reason: "Accurate and natural, consistent terminology",
-            },
-            consistency: { score: 5, reason: "Completely consistent" },
-            purposeAlignment: { score: 5, reason: "Completely meets objectives, closely related" },
-            audienceAlignment: { score: 4, reason: "Generally fits with minor mismatches" },
-            knowledgeLevelAlignment: {
-              score: 4,
-              reason: "Mostly matches, slightly too shallow/deep in places",
-            },
-          },
-          codeEvaluation: null,
-        },
-      ],
-      metadata: {
-        documentTitle: "API Usage Guide",
-        evaluator: "test-suite",
-      },
-      basePath: testDir,
-      projectName: "Test Project",
-      projectDesc: "A test project for evaluation",
-      projectLogo: "test-logo.png",
-      documentPurpose: "Provide API documentation",
-      targetAudienceTypes: ["Developers", "DevOps Engineers"],
-      readerKnowledgeLevel: "Intermediate",
-      documentationDepth: "Comprehensive",
-      targetAudience: "Software developers and engineers",
-    };
-
-    // Call the function
-    const result = await generateEvaluationReport(testData);
-
-    // Verify result structure
-    expect(result).toBeDefined();
-    expect(result.message).toBeDefined();
-    expect(result.message).toContain("integrity-report.json");
-    expect(result.message).toContain("doc-smith/evaluate/");
-
-    // Extract report path from result message
-    const reportPathMatch = result.message.match(/`([^`]+\.json)`/);
-    expect(reportPathMatch).toBeTruthy();
-    const reportPath = reportPathMatch[1];
-
-    // Verify file was created
-    expect(existsSync(reportPath)).toBe(true);
-
-    // Read and parse the report
-    const reportContent = await readFile(reportPath, "utf8");
-    const report = JSON.parse(reportContent);
-
-    // Verify report structure
-    expect(report).toBeDefined();
-    expect(report.documentInfo).toBeDefined();
-    expect(report.metadata).toBeDefined();
-    expect(report.structureEvaluation).toBeDefined();
-    expect(report.documentEvaluations).toBeDefined();
-
-    // Verify document info
-    expect(report.documentInfo.projectName).toBe("Test Project");
-    expect(report.documentInfo.projectDesc).toBe("A test project for evaluation");
-    expect(report.documentInfo.projectLogo).toBe("test-logo.png");
-    expect(report.documentInfo.documentPurpose).toBe("Provide API documentation");
-    expect(report.documentInfo.targetAudienceTypes).toEqual(["Developers", "DevOps Engineers"]);
-    expect(report.documentInfo.readerKnowledgeLevel).toBe("Intermediate");
-    expect(report.documentInfo.documentationDepth).toBe("Comprehensive");
-    expect(report.documentInfo.targetAudience).toBe("Software developers and engineers");
-
-    // Verify metadata
-    expect(report.metadata.version).toBe("0.1.0");
-    expect(report.metadata.generatedBy).toBe("AIGNE Doc Smith");
-    expect(report.metadata.generatedAt).toBeDefined();
-    expect(report.metadata.documentCount).toBe(2);
-    expect(report.metadata.documentTitle).toBe("API Usage Guide");
-    expect(report.metadata.evaluator).toBe("test-suite");
-
-    // Verify structure evaluation
-    expect(report.structureEvaluation.type).toBe("document-structure");
-    expect(report.structureEvaluation.results.purposeCoverage).toEqual(
-      testData.structureEvaluation.purposeCoverage,
-    );
-    expect(report.structureEvaluation.results.audienceCoverage).toEqual(
-      testData.structureEvaluation.audienceCoverage,
-    );
-    expect(report.structureEvaluation.results.coverageDepthAlignment).toEqual(
-      testData.structureEvaluation.coverageDepthAlignment,
-    );
-
-    // Verify document evaluations
-    expect(report.documentEvaluations.type).toBe("document-content");
-    expect(report.documentEvaluations.results).toHaveLength(2);
-
-    // Verify individual document evaluations
-    const firstDoc = report.documentEvaluations.results[0];
-    expect(firstDoc.path).toBe("/api/authentication");
-    expect(firstDoc.title).toBe("Authentication");
-    expect(firstDoc.description).toBe("Authentication guide");
-    expect(firstDoc.parentId).toBe(null);
-    expect(firstDoc.documentEvaluation.readability.score).toBe(4);
-    expect(firstDoc.codeEvaluation).toBe(null);
-  });
-
-  test("should handle empty documentation structure", async () => {
-    const testData = {
-      structureEvaluation: {
-        purposeCoverage: {
-          score: 5,
-          reason: "Completely covers all objectives",
-          covered: ["Objective 1", "Objective 2"],
-          missing: [],
-        },
-        audienceCoverage: {
-          score: 5,
-          reason: "Completely covers all audiences",
-          covered: ["Audience 1", "Audience 2"],
-          missing: [],
-        },
-        coverageDepthAlignment: {
-          score: 5,
-          reason: "Depth completely matches expectations",
-        },
-      },
-      originalDocumentStructure: [],
-      metadata: {
-        documentTitle: "Test Document",
-      },
-      basePath: testDir,
-      projectName: "Empty Test Project",
-      projectDesc: "Test project with no documents",
-      projectLogo: "empty-logo.png",
-      documentPurpose: "Test empty structure",
-      targetAudienceTypes: ["Testers"],
-      readerKnowledgeLevel: "Beginner",
-      documentationDepth: "Basic",
-      targetAudience: "Test users",
-    };
-
-    const result = await generateEvaluationReport(testData);
-
-    expect(result).toBeDefined();
-    expect(result.message).toBeDefined();
-
-    // Extract report path from result message
-    const reportPathMatch = result.message.match(/`([^`]+\.json)`/);
-    expect(reportPathMatch).toBeTruthy();
-    const reportPath = reportPathMatch[1];
-
-    expect(existsSync(reportPath)).toBe(true);
-
-    const reportContent = await readFile(reportPath, "utf8");
-    const report = JSON.parse(reportContent);
-
-    expect(report.metadata.documentCount).toBe(0);
-    expect(report.documentEvaluations.results).toHaveLength(0);
-  });
-
-  test("should handle missing optional parameters", async () => {
-    const testData = {
-      structureEvaluation: {
-        purposeCoverage: {
-          score: 3,
-          reason: "Partial coverage",
-        },
-        audienceCoverage: {
-          score: 3,
-          reason: "Partial coverage",
-        },
-        coverageDepthAlignment: {
-          score: 3,
-          reason: "Generally compliant",
-        },
-      },
-      originalDocumentStructure: [
-        {
-          path: "/test",
-          title: "Test Document",
-          description: "Test document description",
-          parentId: null,
-          documentEvaluation: {
-            readability: { score: 3, reason: "Fair" },
-            coherence: { score: 3, reason: "Fair" },
-            contentQuality: { score: 3, reason: "Fair" },
-            translationQuality: { score: 3, reason: "Fair" },
-            consistency: { score: 3, reason: "Fair" },
-            purposeAlignment: { score: 3, reason: "Fair" },
-            audienceAlignment: { score: 3, reason: "Fair" },
-            knowledgeLevelAlignment: { score: 3, reason: "Fair" },
-          },
-          codeEvaluation: null,
-        },
-      ],
-      basePath: testDir,
-      projectName: "Minimal Test Project",
-      projectDesc: "Minimal test setup",
-      projectLogo: "minimal-logo.png",
-      documentPurpose: "Test minimal configuration",
-      targetAudienceTypes: ["General Users"],
-      readerKnowledgeLevel: "Basic",
-      documentationDepth: "Minimal",
-      targetAudience: "General audience",
-      // metadata is optional
-    };
-
-    const result = await generateEvaluationReport(testData);
-
-    expect(result).toBeDefined();
-    expect(result.message).toBeDefined();
-
-    // Extract report path from result message
-    const reportPathMatch = result.message.match(/`([^`]+\.json)`/);
-    expect(reportPathMatch).toBeTruthy();
-    const reportPath = reportPathMatch[1];
-
-    expect(existsSync(reportPath)).toBe(true);
-
-    const reportContent = await readFile(reportPath, "utf8");
-    const report = JSON.parse(reportContent);
-
-    expect(report.metadata.version).toBe("0.1.0");
-    expect(report.metadata.generatedBy).toBe("AIGNE Doc Smith");
-    expect(report.metadata.documentCount).toBe(1);
-  });
-});