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

package/utils/file-utils.mjs

@@ -559,36 +559,81 @@ export function getStructurePlanPath(workDir) {
   return path.join(cwd, ".aigne", "doc-smith", "output", "structure-plan.json");
 }
 
+// Shared extension → MIME type mapping table
+const EXT_TO_MIME = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".heic": "image/heic",
+  ".heif": "image/heif",
+  ".mp4": "video/mp4",
+  ".mpeg": "video/mpeg",
+  ".mpg": "video/mpg",
+  ".mov": "video/mov",
+  ".avi": "video/avi",
+  ".flv": "video/x-flv",
+  ".mkv": "video/x-matroska",
+  ".webm": "video/webm",
+  ".wmv": "video/wmv",
+  ".m4v": "video/x-m4v",
+  ".3gpp": "video/3gpp",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".pdf": "application/pdf",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xls": "application/vnd.ms-excel",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".ppt": "application/vnd.ms-powerpoint",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ".txt": "text/plain",
+  ".json": "application/json",
+  ".xml": "application/xml",
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".zip": "application/zip",
+  ".rar": "application/x-rar-compressed",
+  ".7z": "application/x-7z-compressed",
+};
+
+// Build reverse mapping: MIME → extensions
+const MIME_TO_EXTS = Object.entries(EXT_TO_MIME).reduce((acc, [ext, mime]) => {
+  const key = mime.toLowerCase();
+  if (!acc[key]) {
+    acc[key] = [];
+  }
+  acc[key].push(ext);
+  return acc;
+}, {});
+
 /**
  * Get MIME type from file path based on extension
  * @param {string} filePath - File path
  * @returns {string} MIME type
  */
 export function getMimeType(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  const mimeTypes = {
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".png": "image/png",
-    ".gif": "image/gif",
-    ".bmp": "image/bmp",
-    ".webp": "image/webp",
-    ".svg": "image/svg+xml",
-    ".heic": "image/heic",
-    ".heif": "image/heif",
-    ".mp4": "video/mp4",
-    ".mpeg": "video/mpeg",
-    ".mpg": "video/mpg",
-    ".mov": "video/mov",
-    ".avi": "video/avi",
-    ".flv": "video/x-flv",
-    ".mkv": "video/x-matroska",
-    ".webm": "video/webm",
-    ".wmv": "video/wmv",
-    ".m4v": "video/x-m4v",
-    ".3gpp": "video/3gpp",
-  };
-  return mimeTypes[ext] || "application/octet-stream";
+  const ext = path.extname(filePath || "").toLowerCase();
+  return EXT_TO_MIME[ext] || "application/octet-stream";
+}
+
+/**
+ * Get file extension (without dot) from content type
+ * Handles content types with parameters (e.g., "image/jpeg; charset=utf-8")
+ * @param {string} contentType - Content type string
+ * @returns {string} File extension without dot
+ */
+export function getExtnameFromContentType(contentType) {
+  if (!contentType) return "";
+  const base = String(contentType).split(";")[0].trim().toLowerCase();
+  const exts = MIME_TO_EXTS[base];
+  if (exts?.length) return exts[0].slice(1); // Remove leading dot
+  const parts = base.split("/");
+  return parts[1] || "";
 }
 
 /**

package/utils/markdown-checker.mjs

@@ -1,14 +1,11 @@
 import fs from "node:fs";
 import path from "node:path";
-import pMap from "p-map";
 import remarkGfm from "remark-gfm";
 import remarkLint from "remark-lint";
 import remarkParse from "remark-parse";
 import { unified } from "unified";
 import { visit } from "unist-util-visit";
 import { VFile } from "vfile";
-import { KROKI_CONCURRENCY } from "./constants/index.mjs";
-import { checkContent, isValidCode } from "./d2-utils.mjs";
 import { validateMermaidSyntax } from "./mermaid-validator.mjs";
 
 /**
@@ -378,7 +375,6 @@ export async function checkMarkdown(markdown, source = "content", options = {})
 
     // Check mermaid code blocks and other custom validations
     const mermaidChecks = [];
-    const d2ChecksList = [];
     visit(ast, "code", (node) => {
       if (node.lang) {
         const line = node.position?.start?.line || "unknown";
@@ -467,12 +463,6 @@ export async function checkMarkdown(markdown, source = "content", options = {})
             specialCharMatch = nodeWithSpecialCharsRegex.exec(mermaidContent);
           }
         }
-        if (isValidCode(node.lang)) {
-          d2ChecksList.push({
-            content: node.value,
-            line,
-          });
-        }
       }
     });
 
@@ -524,16 +514,6 @@ export async function checkMarkdown(markdown, source = "content", options = {})
     // Wait for all mermaid checks to complete
     await Promise.all(mermaidChecks);
 
-    await pMap(
-      d2ChecksList,
-      async ({ content, line }) =>
-        checkContent({ content }).catch((err) => {
-          const errorMessage = err?.message || String(err) || "Unknown d2 syntax error";
-          errorMessages.push(`Found D2 syntax error in ${source} at line ${line}: ${errorMessage}`);
-        }),
-      { concurrency: KROKI_CONCURRENCY },
-    );
-
     // Run markdown linting rules
     await processor.run(ast, file);
 

package/utils/request.mjs

@@ -0,0 +1,7 @@
+export async function requestWithAuthToken(url, options, authToken) {
+  const response = await fetch(url, {
+    ...options,
+    headers: { ...options.headers, Authorization: `Bearer ${authToken}` },
+  });
+  return response.json();
+}

package/utils/upload-files.mjs

@@ -0,0 +1,231 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+import pLimit from "p-limit";
+import pRetry from "p-retry";
+
+import { getComponentMountPoint } from "./blocklet.mjs";
+import { DISCUSS_KIT_DID } from "./constants/index.mjs";
+import { getMimeType } from "./file-utils.mjs";
+
+/**
+ * Perform single file upload
+ */
+async function performSingleUpload(filePath, fileHash, uploadEndpoint, accessToken, url) {
+  const baseFilename = path.basename(filePath, path.extname(filePath));
+  const fileBuffer = fs.readFileSync(filePath);
+  const stats = fs.statSync(filePath);
+  const fileSize = stats.size;
+  const fileExt = path.extname(filePath).substring(1);
+  const mimeType = getMimeType(filePath);
+
+  const hashBasedFilename = `${fileHash.substring(0, 16)}.${fileExt}`;
+
+  const uploaderId = "Uploader";
+  const fileId = `${uploaderId}-${baseFilename.toLowerCase().replace(/[^a-z0-9]/g, "")}-${fileHash.substring(0, 16)}`;
+
+  const tusMetadata = {
+    uploaderId,
+    relativePath: hashBasedFilename,
+    name: hashBasedFilename,
+    type: mimeType,
+    filetype: mimeType,
+    filename: hashBasedFilename,
+  };
+
+  const encodedMetadata = Object.entries(tusMetadata)
+    .map(([key, value]) => `${key} ${Buffer.from(value).toString("base64")}`)
+    .join(",");
+
+  const uploadEndpointUrl = new URL(uploadEndpoint);
+  const endpointPath = uploadEndpointUrl.pathname;
+
+  // Create upload
+  const createResponse = await fetch(uploadEndpoint, {
+    method: "POST",
+    headers: {
+      "Tus-Resumable": "1.0.0",
+      "Upload-Length": fileSize.toString(),
+      "Upload-Metadata": encodedMetadata,
+      Cookie: `login_token=${accessToken}`,
+      "x-uploader-file-name": hashBasedFilename,
+      "x-uploader-file-id": fileId,
+      "x-uploader-file-ext": fileExt,
+      "x-uploader-base-url": endpointPath,
+      "x-uploader-endpoint-url": uploadEndpoint,
+      "x-uploader-metadata": JSON.stringify({
+        uploaderId,
+        relativePath: hashBasedFilename,
+        name: hashBasedFilename,
+        type: mimeType,
+      }),
+      "x-component-did": DISCUSS_KIT_DID,
+    },
+  });
+
+  if (!createResponse.ok) {
+    const errorText = await createResponse.text();
+    throw new Error(
+      `Failed to create upload: ${createResponse.status} ${createResponse.statusText}\n${errorText}`,
+    );
+  }
+
+  const uploadUrl = createResponse.headers.get("Location");
+  if (!uploadUrl) {
+    throw new Error("No upload URL received from server");
+  }
+
+  // Upload file content
+  const uploadResponse = await fetch(`${url.origin}${uploadUrl}`, {
+    method: "PATCH",
+    headers: {
+      "Tus-Resumable": "1.0.0",
+      "Upload-Offset": "0",
+      "Content-Type": "application/offset+octet-stream",
+      Cookie: `login_token=${accessToken}`,
+      "x-uploader-file-name": hashBasedFilename,
+      "x-uploader-file-id": fileId,
+      "x-uploader-file-ext": fileExt,
+      "x-uploader-base-url": endpointPath,
+      "x-uploader-endpoint-url": uploadEndpoint,
+      "x-uploader-metadata": JSON.stringify({
+        uploaderId,
+        relativePath: hashBasedFilename,
+        name: hashBasedFilename,
+        type: mimeType,
+      }),
+      "x-component-did": DISCUSS_KIT_DID,
+      "x-uploader-file-exist": "true",
+    },
+    body: fileBuffer,
+  });
+
+  if (!uploadResponse.ok) {
+    const errorText = await uploadResponse.text();
+    throw new Error(
+      `Failed to upload file: ${uploadResponse.status} ${uploadResponse.statusText}\n${errorText}`,
+    );
+  }
+
+  const uploadResult = await uploadResponse.json();
+
+  let uploadedFileUrl = uploadResult.url;
+  if (!uploadedFileUrl && uploadResult?.size) {
+    uploadedFileUrl = uploadResponse.url;
+  }
+
+  if (!uploadedFileUrl) {
+    throw new Error("No URL found in the upload response");
+  }
+
+  return {
+    filePath,
+    url: uploadedFileUrl,
+  };
+}
+
+/**
+ * Upload multiple files with concurrency control
+ * @param {Object} options - Upload options
+ * @param {string} options.appUrl - Application URL
+ * @param {string[]} options.filePaths - Array of file paths to upload
+ * @param {string} options.accessToken - Access token for authentication
+ * @param {number} [options.concurrency=3] - Number of concurrent uploads
+ * @param {string} [options.endpoint] - Custom upload endpoint
+ * @returns {Promise<{results: Array<{filePath: string, url: string}>}>}
+ */
+export async function uploadFiles(options) {
+  const { appUrl, filePaths, endpoint, concurrency = 3, accessToken } = options;
+
+  if (filePaths.length === 0) {
+    return { results: [] };
+  }
+
+  const url = new URL(appUrl);
+  const mountPoint = await getComponentMountPoint(appUrl, DISCUSS_KIT_DID);
+
+  // Use custom endpoint or default to discuss kit media endpoint
+  const uploadEndpoint = endpoint || `${url.origin}${mountPoint}/api/uploads`;
+
+  const limit = pLimit(concurrency);
+  const ongoingUploads = new Map();
+
+  const uploadPromises = filePaths.map((filePath) =>
+    limit(async () => {
+      const filename = path.basename(filePath);
+
+      try {
+        const fileBuffer = fs.readFileSync(filePath);
+        const fileHash = crypto.createHash("sha256").update(fileBuffer).digest("hex");
+
+        // Check if this file is already being uploaded
+        const existingUpload = ongoingUploads.get(fileHash);
+        if (existingUpload) {
+          const result = await existingUpload;
+          return {
+            filePath,
+            url: result.url,
+          };
+        }
+
+        // Create upload promise and cache it
+        const uploadPromise = (async () => {
+          try {
+            const result = await pRetry(
+              () => performSingleUpload(filePath, fileHash, uploadEndpoint, accessToken, url),
+              {
+                retries: 3,
+                onFailedAttempt: (error) => {
+                  console.warn(
+                    `File upload attempt ${error.attemptNumber} failed for "${filename}". Remaining retries: ${error.retriesLeft}`,
+                  );
+                  if (error.retriesLeft === 0) {
+                    console.error(
+                      `File upload failed - all retry attempts exhausted for "${filename}"`,
+                    );
+                  }
+                },
+              },
+            );
+
+            return result;
+          } catch (error) {
+            console.error(
+              `File upload failed - error uploading "${filename}" after all retries:`,
+              error,
+            );
+            return {
+              filePath,
+              url: "",
+            };
+          }
+        })();
+
+        // Cache the upload promise
+        ongoingUploads.set(fileHash, uploadPromise);
+
+        try {
+          const result = await uploadPromise;
+          return {
+            filePath,
+            url: result.url,
+          };
+        } finally {
+          // Clean up the ongoing upload tracking
+          ongoingUploads.delete(fileHash);
+        }
+      } catch (error) {
+        console.error(`Error processing ${filename}:`, error);
+        return {
+          filePath,
+          url: "",
+        };
+      }
+    }),
+  );
+
+  const uploadResults = await Promise.all(uploadPromises);
+
+  return { results: uploadResults };
+}

package/utils/utils.mjs

@@ -47,6 +47,16 @@ export function isGlobPattern(pattern) {
   return /[*?[\]]|(\*\*)/.test(pattern);
 }
 
+/**
+ * Check if a string is an HTTP/HTTPS URL
+ * @param {string} url - The string to check
+ * @returns {boolean} - True if the string starts with http:// or https://
+ */
+export function isHttp(url) {
+  if (typeof url !== "string") return false;
+  return url.startsWith("http://") || url.startsWith("https://");
+}
+
 export function processContent({ content }) {
   // Match markdown regular links [text](link), exclude images ![text](link)
   return content.replace(/(?<!!)\[([^\]]+)\]\(([^)]+)\)/g, (match, text, link) => {
@@ -1112,7 +1122,7 @@ export async function resolveFileReferences(obj, basePath = process.cwd()) {
  * @param {string} basePath - Base path for resolving relative paths
  * @returns {Promise<any>} - The loaded content or original path if loading fails
  */
-async function loadFileContent(filePath, basePath) {
+export async function loadFileContent(filePath, basePath) {
   try {
     // Resolve path - if absolute, use as is; if relative, resolve from basePath
     const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(basePath, filePath);

package/.aigne/doc-smith/config.yaml

@@ -1,77 +0,0 @@
-# Project information for documentation publishing
-projectName: AIGNE DocSmith
-projectDesc: AIGNE DocSmith is a powerful, AI-driven documentation generation tool built on the AIGNE Framework. It automates the creation of detailed, structured, and multi-language documentation directly from your source code.
-projectLogo: https://docsmith.aigne.io/image-bin/uploads/9645caf64b4232699982c4d940b03b90.svg
-
-# =============================================================================
-# Documentation Configuration
-# =============================================================================
-
-# Purpose: What's the main outcome you want readers to achieve?
-# Available options (uncomment and modify as needed):
-#   getStarted       - Get started quickly: Help new users go from zero to working in <30 minutes
-#   completeTasks    - Complete specific tasks: Guide users through common workflows and use cases
-#   findAnswers      - Find answers fast: Provide searchable reference for all features and APIs
-#   understandSystem - Understand the system: Explain how it works, why design decisions were made
-#   solveProblems    - Solve problems: Help users troubleshoot and fix issues
-#   mixedPurpose     - Mix of above: Comprehensive documentation covering multiple needs
-documentPurpose:
-  - getStarted
-  - completeTasks
-
-# Target Audience: Who will be reading this most often?
-# Available options (uncomment and modify as needed):
-#   endUsers         - End users (non-technical): People who use the product but don't code
-#   developers       - Developers integrating: Engineers adding this to their projects
-#   devops           - DevOps/Infrastructure: Teams deploying, monitoring, maintaining systems
-#   decisionMakers   - Technical decision makers: Architects, leads evaluating or planning implementation
-#   supportTeams     - Support teams: People helping others use the product
-#   mixedTechnical   - Mixed technical audience: Developers, DevOps, and technical users
-targetAudienceTypes:
-  - endUsers
-
-# Reader Knowledge Level: What do readers typically know when they arrive?
-# Available options (uncomment and modify as needed):
-#   completeBeginners    - Complete beginners: New to this domain/technology entirely
-#   domainFamiliar       - Domain-familiar, tool-new: Know the problem space, new to this specific solution
-#   experiencedUsers     - Experienced users: Regular users needing reference/advanced topics
-#   emergencyTroubleshooting - Emergency/troubleshooting: Something's broken, need to fix it quickly
-#   exploringEvaluating  - Exploring/evaluating: Trying to understand if this fits their needs
-readerKnowledgeLevel: completeBeginners
-
-# Documentation Depth: How comprehensive should the documentation be?
-# Available options (uncomment and modify as needed):
-#   essentialOnly      - Essential only: Cover the 80% use cases, keep it concise
-#   balancedCoverage   - Balanced coverage: Good depth with practical examples [RECOMMENDED]
-#   comprehensive      - Comprehensive: Cover all features, edge cases, and advanced scenarios
-#   aiDecide           - Let AI decide: Analyze code complexity and suggest appropriate depth
-documentationDepth: comprehensive
-
-# Custom Rules: Define specific documentation generation rules and requirements
-rules: |
-  Avoid using vague or empty words that don't provide measurable or specific details, such as 'intelligently', 'seamlessly', 'comprehensive', or 'high-quality'. Focus on concrete, verifiable facts and information.
-  Focus on concrete, verifiable facts and information.
-  Must cover all subcommands of DocSmith
-
-# Target Audience: Describe your specific target audience and their characteristics
-targetAudience: |
-
-locale: en
-translateLanguages:
-  - zh
-  - zh-TW
-  - ja
-docsDir: ./docs  # Directory to save generated documentation
-sourcesPath:  # Source code paths to analyze
-  - ./README.md
-  - ./CHANGELOG.md
-  - ./aigne.yaml
-  - ./agents
-  - ./.aigne/doc-smith/config.yaml
-  - ./assets/screenshots
-lastGitHead: f0db74dffd0876dab4cc3ad628523abd359c9430
-# ⚠️ Warning: boardId is auto-generated by system, please do not edit manually
-boardId: "docsmith"
-appUrl: https://docsmith.aigne.io
-# Checkout ID for document deployment service
-checkoutId: ""

package/.aigne/doc-smith/history.yaml

@@ -1,37 +0,0 @@
-entries:
-  - timestamp: 2025-10-11T13:21:51.992Z
-    operation: translation_update
-    feedback: Do not translate the Target column in the Cleanup Targets table.
-    documentPath: /guides/cleaning-up
-  - timestamp: 2025-10-11T13:20:30.314Z
-    operation: document_update
-    feedback: The targets in Cleanup Targets are incomplete and need to be supplemented. The corresponding descriptions also require updating. Additionally, the target values should use the original enumeration values, such as 'generatedDocs'.
-    documentPath: /guides/cleaning-up
-  - timestamp: 2025-10-11T13:03:20.327Z
-    operation: document_update
-    feedback: The two aliases for the 'history' command in Viewing Update History can be combined into a single code block. The Short Hash in Understanding the History Output now consists of 8 characters. Additionally, operation types are separated by underscores, such as 'document_update'.
-    documentPath: /guides/managing-history
-  - timestamp: 2025-10-11T12:56:23.107Z
-    operation: document_update
-    feedback: In interactive mode, translated files are saved with a suffix appended to their original filenames within the same directory, rather than in dedicated language directories.
-    documentPath: /guides/translating-documentation
-  - timestamp: 2025-10-11T12:50:25.563Z
-    operation: document_update
-    feedback: The value of the 'docs' parameter in the demo should be a path separated by '-' rather than '/', and '.md' should be preserved.
-    documentPath: /guides/updating-documentation
-  - timestamp: 2025-10-11T12:46:37.507Z
-    operation: document_update
-    feedback: The value of the 'docs' parameter in the demo should be a path separated by '-' rather than '/'.
-    documentPath: /guides/updating-documentation
-  - timestamp: 2025-10-11T12:39:53.222Z
-    operation: document_update
-    feedback: The prompts in Review the Documentation Structure are outdated and need updating. Command Parameters also require updating.
-    documentPath: /guides/generating-documentation
-  - timestamp: 2025-10-11T12:26:24.598Z
-    operation: translation_update
-    feedback: AIGNE Framework is a proper noun and has its own link; no translation is required.
-    documentPath: /overview
-  - timestamp: 2025-10-11T12:24:05.477Z
-    operation: document_update
-    feedback: Add a link to the AIGNE Framework 'https://www.aigne.io/framework'.
-    documentPath: /overview

package/.aigne/doc-smith/media-description.yaml

@@ -1,91 +0,0 @@
-descriptions:
-  5838723847ec201191b002ef7d44937d92386a82755ca7a66374acff6b91325e:
-    path: ../assets/screenshots/doc-translate.png
-    description: This screenshot illustrates a user interface for document
-      translation. It displays options for selecting the source and target
-      languages, along with an area for document input or upload. The image
-      demonstrates the initial steps for translating a document within a
-      software application or web service.
-    generatedAt: 2025-10-13T10:16:56.300Z
-  ac51399fcd5ba2e36d7c84264dd28624acd10c57aa82f7d006da6f8434cb24de:
-    path: ../assets/screenshots/doc-regenerate.png
-    description: This screenshot displays a user interface element for a
-      'Regenerate' function, likely within an application or content management
-      system. It visually demonstrates how users can trigger the re-rendering or
-      updating of content, often showing a button or control and potentially the
-      immediate output or status of the regeneration process.
-    generatedAt: 2025-10-13T10:16:56.301Z
-  9871bff567cc5f1b73e99b84c03781bffc7f531635b9bd40f23a2aee5f9885e5:
-    path: ../assets/screenshots/doc-update.png
-    description: This image is a screenshot depicting a user interface for updating
-      documentation content. It showcases a main text editing area, likely with
-      rich text formatting capabilities, accompanied by buttons for actions such
-      as saving, previewing, or publishing changes. The layout suggests a
-      content management system or a wiki-style editing environment.
-    generatedAt: 2025-10-13T10:16:56.301Z
-  31353781ba6d1572359823faa399af9f5deca7b994f24939cb5f5143fcc96b14:
-    path: ../assets/screenshots/doc-translate-langs.png
-    description: This screenshot depicts a user interface element focused on
-      language selection for documentation translation. It displays a list or
-      menu of languages, allowing users to choose or configure the target
-      languages for translating documentation content. The image highlights the
-      functionality for managing multilingual documentation.
-    generatedAt: 2025-10-13T10:16:56.301Z
-  a42903e87ae020dcb81991e672b2a2990b94eb0e92d6c1cc87f3bf6223355344:
-    path: ../assets/screenshots/doc-publish.png
-    description: This is a screenshot of a "Publish Documentation" dialog box from a
-      user interface. It presents options for selecting documentation to publish
-      and configuring various publication settings, including checkboxes for
-      search indexing and versioning. The dialog features "Cancel" and "Publish"
-      action buttons at the bottom right.
-    generatedAt: 2025-10-13T10:16:56.301Z
-  c055a80de6c1120765757fd3ef91ef05718f77beb7d6dfdac41d8e234361a68a:
-    path: ../assets/screenshots/doc-generated-successfully.png
-    description: This is a screenshot of a success notification banner,
-      characterized by its wide and short dimensions. It displays a positive
-      message such as "Document generated successfully," likely accompanied by a
-      green checkmark or other visual cues indicating a successful operation.
-      This image is suitable for illustrating UI feedback when a document
-      generation process is completed.
-    generatedAt: 2025-10-13T10:16:56.301Z
-  f786c36289e0e5bfea866c9384edc7d44996c42adfad0cb6f613f46e27f0f2be:
-    path: ../assets/screenshots/doc-generate.png
-    description: This screenshot displays a "Generate Documentation" dialog,
-      presenting various options for outputting documentation files. Users can
-      specify an output path, choose to include example content, overwrite
-      existing files, and generate the documentation in dark mode, before
-      confirming with "Generate" or "Cancel."
-    generatedAt: 2025-10-13T10:16:56.301Z
-  2b41c70c6a61942727984b2d99010cbe7e1d9b4c75686f65af8b5a245e9b800d:
-    path: ../assets/screenshots/doc-generate-docs.png
-    description: This image is a screenshot illustrating a user interface for a
-      documentation generation process. It depicts a dialog or panel with
-      various configuration options and controls, likely including output format
-      selections and a prominent "Generate" button to initiate the creation of
-      documentation.
-    generatedAt: 2025-10-13T10:16:56.301Z
-  44cb2fc222a3dd15fa82f1088d9113b0bb1bfc8b29a0e568a2273d80e8f50a7d:
-    path: ../assets/screenshots/doc-complete-setup.png
-    description: This screenshot depicts the "Setup Complete" screen from a user
-      interface, indicating the successful conclusion of an installation or
-      configuration process. It features a prominent confirmation message, such
-      as "Setup Complete!", often accompanied by a success icon and an
-      actionable button like "Continue" or "Go to Dashboard" to proceed.
-    generatedAt: 2025-10-13T10:16:56.301Z
-  13a9073d16762909e189af4e53ceb004abe1c55681d12726fceb262205fbf180:
-    path: ../assets/screenshots/doc-generate.png
-    description: This screenshot displays a user interface for generating
-      documentation. It features various input fields and controls, likely for
-      configuring options such as output format, target location, and content
-      selection. The image serves to illustrate the steps or settings involved
-      in the documentation generation process.
-    generatedAt: 2025-10-13T14:07:35.096Z
-  90c0daa8347df01c8154b6a5b30879b691c4a94b49c970b0480435591603bf55:
-    path: ../assets/screenshots/doc-complete-setup.png
-    description: This image is a screenshot displaying a "Setup Complete" success
-      message within a user interface. It shows a clear green checkmark icon, a
-      bold headline confirming the setup is finished, and additional descriptive
-      text below. A prominent "Done" button is visible at the bottom of the
-      interface, indicating the next action for the user.
-    generatedAt: 2025-10-13T14:07:35.097Z
-lastUpdated: 2025-10-13T14:07:35.098Z