@aigne/doc-smith 0.8.11-beta.5 → 0.8.11-beta.6

package/tests/agents/clear/clear-document-structure.test.mjs

@@ -34,8 +34,8 @@ describe("clear-document-structure", () => {
     }
   });
 
-  test("should clear structure plan only when no docsDir provided", async () => {
-    // Create a test structure plan file
+  test("should clear documentation structure only when no docsDir provided", async () => {
+    // Create a test documentation structure file
     const structurePlan = {
       documents: [
         { path: "/intro", title: "Introduction" },
@@ -46,18 +46,18 @@ describe("clear-document-structure", () => {
 
     const result = await clearDocumentStructure({ workDir: testDir });
 
-    expect(result.message).toContain("Document structure cleared successfully!");
+    expect(result.message).toContain("Documentation Structure cleared successfully!");
     expect(result.hasError).toBe(false);
     expect(result.clearedCount).toBe(1);
 
-    // Verify structure plan file is actually deleted
+    // Verify documentation structure file is actually deleted
     const { pathExists } = await import("../../../utils/file-utils.mjs");
     const exists = await pathExists(structurePlanPath);
     expect(exists).toBe(false);
   });
 
-  test("should clear both structure plan and docs directory when docsDir provided", async () => {
-    // Create structure plan
+  test("should clear both documentation structure and docs directory when docsDir provided", async () => {
+    // Create documentation structure
     await writeFile(structurePlanPath, JSON.stringify({ test: "data" }));
 
     // Create docs directory with files
@@ -67,7 +67,7 @@ describe("clear-document-structure", () => {
 
     const result = await clearDocumentStructure({ workDir: testDir, docsDir });
 
-    expect(result.message).toContain("Document structure cleared successfully!");
+    expect(result.message).toContain("Documentation Structure cleared successfully!");
     expect(result.clearedCount).toBe(2);
 
     // Verify both are deleted
@@ -78,17 +78,17 @@ describe("clear-document-structure", () => {
     expect(docsExists).toBe(false);
   });
 
-  test("should handle non-existent structure plan file", async () => {
-    // Don't create the structure plan file
+  test("should handle non-existent documentation structure file", async () => {
+    // Don't create the documentation structure file
     const result = await clearDocumentStructure({ workDir: testDir });
 
-    expect(result.message).toContain("Document structure already empty.");
+    expect(result.message).toContain("Documentation Structure already empty.");
     expect(result.clearedCount).toBe(0);
     expect(result.hasError).toBe(false);
   });
 
   test("should handle non-existent docs directory", async () => {
-    // Create structure plan but not docs directory
+    // Create documentation structure but not docs directory
     await writeFile(structurePlanPath, JSON.stringify({ test: "data" }));
 
     const nonExistentDocsDir = join(testDir, "non-existent-docs");
@@ -98,10 +98,10 @@ describe("clear-document-structure", () => {
       docsDir: nonExistentDocsDir,
     });
 
-    expect(result.message).toContain("Document structure cleared successfully!");
-    expect(result.clearedCount).toBe(1); // Only structure plan cleared
+    expect(result.message).toContain("Documentation Structure cleared successfully!");
+    expect(result.clearedCount).toBe(1); // Only documentation structure cleared
 
-    // Verify structure plan is deleted
+    // Verify documentation structure is deleted
     const { pathExists } = await import("../../../utils/file-utils.mjs");
     const exists = await pathExists(structurePlanPath);
     expect(exists).toBe(false);
@@ -114,12 +114,12 @@ describe("clear-document-structure", () => {
       // Change to test directory
       process.chdir(testDir);
 
-      // Create structure plan in current directory's structure
+      // Create documentation structure in current directory's structure
       await writeFile(structurePlanPath, JSON.stringify({ test: "data" }));
 
       const result = await clearDocumentStructure({});
 
-      expect(result.message).toContain("Document structure cleared successfully!");
+      expect(result.message).toContain("Documentation Structure cleared successfully!");
       expect(result.clearedCount).toBe(1);
     } finally {
       // Restore original working directory
@@ -159,15 +159,15 @@ describe("clear-document-structure", () => {
 
   test("should have correct task metadata", () => {
     expect(clearDocumentStructure.taskTitle).toBe(
-      "Clear document structure and all generated documents",
+      "Clear documentation structure and all generated documents",
     );
     expect(clearDocumentStructure.description).toBe(
-      "Clear the document structure plan (structure-plan.json) and optionally the documents directory",
+      "Clear the documentation structure (structure-plan.json) and optionally the documents directory",
     );
   });
 
-  test("should handle complex document structures", async () => {
-    // Create complex structure plan
+  test("should handle complex documentation structures", async () => {
+    // Create complex documentation structure
     const complexStructure = {
       documents: [
         {
@@ -289,7 +289,7 @@ describe("clear-document-structure", () => {
     const structureResult = result.results.find((r) => r.type === "structure");
     expect(structureResult).toBeDefined();
     expect(structureResult.cleared).toBe(true);
-    expect(structureResult.message).toContain("structure plan");
+    expect(structureResult.message).toContain("documentation structure");
 
     // Check documents result
     const docsResult = result.results.find((r) => r.type === "documents");
@@ -298,12 +298,12 @@ describe("clear-document-structure", () => {
     expect(docsResult.message).toContain("documents directory");
   });
 
-  test("should handle structure plan file removal errors", async () => {
-    // Create a spy on rm to simulate an error for structure plan
+  test("should handle documentation structure file removal errors", async () => {
+    // Create a spy on rm to simulate an error for documentation structure
     const rmSpy = spyOn(fsPromises, "rm");
     rmSpy.mockImplementation((path, _options) => {
       if (path.includes("structure-plan.json")) {
-        throw new Error("Permission denied for structure plan");
+        throw new Error("Permission denied for documentation structure");
       }
       return Promise.resolve();
     });
@@ -312,19 +312,21 @@ describe("clear-document-structure", () => {
       const result = await clearDocumentStructure({ workDir: testDir });
 
       expect(result.hasError).toBe(true);
-      expect(result.message).toContain("Document structure cleanup finished with some issues.");
+      expect(result.message).toContain(
+        "Documentation Structure cleanup finished with some issues.",
+      );
 
       const structureResult = result.results.find((r) => r.type === "structure");
       expect(structureResult.error).toBe(true);
-      expect(structureResult.message).toContain("Failed to clear document structure plan");
-      expect(structureResult.message).toContain("Permission denied for structure plan");
+      expect(structureResult.message).toContain("Failed to clear documentation structure");
+      expect(structureResult.message).toContain("Permission denied for documentation structure");
     } finally {
       rmSpy.mockRestore();
     }
   });
 
   test("should handle documents directory removal errors", async () => {
-    // Create structure plan file
+    // Create documentation structure file
     await writeFile(structurePlanPath, JSON.stringify({ test: "data" }));
 
     // Create a spy on rm to simulate an error for docs directory
@@ -340,7 +342,9 @@ describe("clear-document-structure", () => {
       const result = await clearDocumentStructure({ workDir: testDir, docsDir });
 
       expect(result.hasError).toBe(true);
-      expect(result.message).toContain("Document structure cleanup finished with some issues.");
+      expect(result.message).toContain(
+        "Documentation Structure cleanup finished with some issues.",
+      );
 
       const docsResult = result.results.find((r) => r.type === "documents");
       expect(docsResult.error).toBe(true);
@@ -362,7 +366,9 @@ describe("clear-document-structure", () => {
       const result = await clearDocumentStructure({ workDir: testDir, docsDir });
 
       expect(result.hasError).toBe(true);
-      expect(result.message).toContain("Document structure cleanup finished with some issues.");
+      expect(result.message).toContain(
+        "Documentation Structure cleanup finished with some issues.",
+      );
       expect(result.results).toHaveLength(2);
 
       // Both operations should have errors

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

@@ -189,7 +189,7 @@ describe("generateEvaluationReport", () => {
     expect(firstDoc.codeEvaluation).toBe(null);
   });
 
-  test("should handle empty document structure", async () => {
+  test("should handle empty documentation structure", async () => {
     const testData = {
       structureEvaluation: {
         purposeCoverage: {

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

@@ -87,7 +87,7 @@ describe("check-need-generate-structure", () => {
     saveValueToConfigSpy?.mockRestore();
   });
 
-  test("should return original document structure when no regeneration needed", async () => {
+  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" },

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

@@ -335,7 +335,7 @@ describe("add-document", () => {
   });
 
   // EDGE CASES
-  test("should handle empty document structure", async () => {
+  test("should handle empty documentation structure", async () => {
     const result = await addDocument({
       documentStructure: [],
       title: "First Document",
@@ -418,7 +418,7 @@ describe("add-document", () => {
   });
 
   // DATA INTEGRITY TESTS
-  test("should not modify original document structure", async () => {
+  test("should not modify original documentation structure", async () => {
     const originalStructure = [...baseDocumentStructure];
 
     await addDocument({

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

@@ -197,7 +197,7 @@ describe("delete-document", () => {
   });
 
   // EDGE CASES
-  test("should handle empty document structure", async () => {
+  test("should handle empty documentation structure", async () => {
     const result = await deleteDocument({
       documentStructure: [],
       path: "/any-path",
@@ -210,7 +210,7 @@ describe("delete-document", () => {
     );
   });
 
-  test("should handle document structure with single document", async () => {
+  test("should handle documentation structure with single document", async () => {
     const singleDocStructure = [
       {
         title: "Only Document",
@@ -313,7 +313,7 @@ describe("delete-document", () => {
   });
 
   // DATA INTEGRITY TESTS
-  test("should not modify original document structure", async () => {
+  test("should not modify original documentation structure", async () => {
     const originalStructure = [...baseDocumentStructure];
 
     await deleteDocument({
@@ -390,7 +390,7 @@ describe("delete-document", () => {
     expect(result.deletedDocument).toHaveProperty("sourceIds");
   });
 
-  test("should return updated document structure without deleted document", async () => {
+  test("should return updated documentation structure without deleted document", async () => {
     const originalLength = baseDocumentStructure.length;
     const result = await deleteDocument({
       documentStructure: baseDocumentStructure,

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

@@ -326,7 +326,7 @@ describe("move-document", () => {
     expect(updatedDoc.parentId).not.toBe(originalDoc.parentId);
   });
 
-  test("should handle empty document structure", async () => {
+  test("should handle empty documentation structure", async () => {
     const result = await moveDocument({
       documentStructure: [],
       path: "/any-path",
@@ -339,7 +339,7 @@ describe("move-document", () => {
     );
   });
 
-  test("should handle single document structure", async () => {
+  test("should handle single documentation structure", async () => {
     const singleDocStructure = [
       {
         title: "Only Document",
@@ -363,7 +363,7 @@ describe("move-document", () => {
   });
 
   // DATA INTEGRITY TESTS
-  test("should not modify original document structure", async () => {
+  test("should not modify original documentation structure", async () => {
     const originalStructure = [...baseDocumentStructure];
 
     await moveDocument({

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

@@ -319,7 +319,7 @@ describe("update-document", () => {
     expect(consoleSpy).not.toHaveBeenCalled();
   });
 
-  test("should handle empty document structure", async () => {
+  test("should handle empty documentation structure", async () => {
     const result = await updateDocument({
       documentStructure: [],
       path: "/any-path",
@@ -332,7 +332,7 @@ describe("update-document", () => {
     );
   });
 
-  test("should handle single document structure", async () => {
+  test("should handle single documentation structure", async () => {
     const singleDocStructure = [
       {
         title: "Only Document",
@@ -377,7 +377,7 @@ describe("update-document", () => {
   });
 
   // DATA INTEGRITY TESTS
-  test("should not modify original document structure", async () => {
+  test("should not modify original documentation structure", async () => {
     const originalStructure = [...baseDocumentStructure];
 
     await updateDocument({

package/tests/agents/generate/user-review-document-structure.test.mjs

@@ -71,13 +71,13 @@ describe("user-review-document-structure", () => {
     consoleSpy?.mockRestore();
   });
 
-  test("should return original structure when no document structure provided", async () => {
+  test("should return original structure when no documentation structure provided", async () => {
     const result = await userReviewDocumentStructure({}, mockOptions);
 
     expect(result).toBeDefined();
     expect(result.documentStructure).toBeUndefined();
     expect(mockOptions.prompts.select).not.toHaveBeenCalled();
-    expect(consoleSpy).toHaveBeenCalledWith("No document structure was generated to review.");
+    expect(consoleSpy).toHaveBeenCalledWith("No documentation structure was generated to review.");
   });
 
   test("should return original structure when empty array provided", async () => {
@@ -86,7 +86,7 @@ describe("user-review-document-structure", () => {
     expect(result).toBeDefined();
     expect(result.documentStructure).toEqual([]);
     expect(mockOptions.prompts.select).not.toHaveBeenCalled();
-    expect(consoleSpy).toHaveBeenCalledWith("No document structure was generated to review.");
+    expect(consoleSpy).toHaveBeenCalledWith("No documentation structure was generated to review.");
   });
 
   test("should return original structure when user chooses not to review", async () => {
@@ -110,7 +110,9 @@ describe("user-review-document-structure", () => {
     expect(result.documentStructure).toEqual(documentStructure);
     expect(mockOptions.prompts.select).toHaveBeenCalled();
     expect(mockOptions.prompts.input).toHaveBeenCalled();
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Current Document Structure"));
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Current Documentation Structure"),
+    );
   });
 
   test("should process user feedback and call refineDocumentStructure agent", async () => {
@@ -188,7 +190,7 @@ describe("user-review-document-structure", () => {
 
     expect(result.documentStructure).toEqual(documentStructure);
     expect(consoleSpy).toHaveBeenCalledWith(
-      "Unable to process your feedback - the document structure update feature is unavailable.",
+      "Unable to process your feedback - the documentation structure update feature is unavailable.",
     );
   });
 

package/tests/agents/update/check-document.test.mjs

@@ -177,7 +177,7 @@ describe("check-document", () => {
     expect(mockOptions.context.invoke).not.toHaveBeenCalled();
   });
 
-  test("should handle missing original node in document structure", async () => {
+  test("should handle missing original node in documentation structure", async () => {
     accessSpy.mockResolvedValue();
     checkDetailResultSpy.mockResolvedValue({ isApproved: true });
 

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

@@ -104,7 +104,7 @@ describe("format-document-structure", () => {
   });
 
   // BASIC FUNCTIONALITY TESTS
-  test("should format empty document structure", async () => {
+  test("should format empty documentation structure", async () => {
     const result = await formatDocumentStructure({
       documentStructure: [],
     });
@@ -121,7 +121,7 @@ describe("format-document-structure", () => {
     });
   });
 
-  test("should format single item document structure", async () => {
+  test("should format single item documentation structure", async () => {
     const documentStructure = [
       {
         title: "Getting Started",
@@ -152,7 +152,7 @@ describe("format-document-structure", () => {
     expect(result.documentStructureYaml).toBe(expectedYaml);
   });
 
-  test("should format multiple items document structure", async () => {
+  test("should format multiple items documentation structure", async () => {
     const documentStructure = [
       {
         title: "API Reference",
@@ -321,7 +321,7 @@ describe("format-document-structure", () => {
     expect(result.documentStructure).toEqual(documentStructure);
   });
 
-  test("should return both yaml string and original document structure", async () => {
+  test("should return both yaml string and original documentation structure", async () => {
     const documentStructure = [
       {
         title: "Return Test",
@@ -339,7 +339,7 @@ describe("format-document-structure", () => {
     expect(result.documentStructure).toBe(documentStructure); // Should be the same reference
   });
 
-  test("should preserve original document structure unchanged", async () => {
+  test("should preserve original documentation structure unchanged", async () => {
     const originalDocumentStructure = [
       {
         title: "Original",

package/tests/agents/utils/load-sources.test.mjs

@@ -1030,8 +1030,8 @@ describe("load-sources", () => {
     });
   });
 
-  describe("Document path and document structure handling", () => {
-    test("should load existing document structure", async () => {
+  describe("Document path and documentation structure handling", () => {
+    test("should load existing documentation structure", async () => {
       const documentStructure = {
         sections: ["Introduction", "API", "Examples"],
         lastUpdated: new Date().toISOString(),
@@ -1050,7 +1050,7 @@ describe("load-sources", () => {
       expect(result.originalDocumentStructure).toEqual(documentStructure);
     });
 
-    test("should handle malformed document structure JSON", async () => {
+    test("should handle malformed documentation structure JSON", async () => {
       await writeFile(path.join(tempDir, "structure-plan.json"), "{ invalid json content");
 
       const result = await loadSources({
@@ -1064,7 +1064,7 @@ describe("load-sources", () => {
       expect(result.originalDocumentStructure).toBeUndefined();
     });
 
-    test("should handle non-ENOENT errors when reading document structure JSON", async () => {
+    test("should handle non-ENOENT errors when reading documentation structure JSON", async () => {
       // Import fs promises module to spy on
       const fsPromises = await import("node:fs/promises");
 

package/tests/agents/utils/save-docs.test.mjs

@@ -52,7 +52,7 @@ describe("save-docs", () => {
     expect(initialFiles).toContain("getting-started.md");
     expect(initialFiles).toContain("old-file.md");
 
-    // Test document structure
+    // Test documentation structure
     const documentStructure = [
       {
         path: "/overview",

package/tests/utils/conflict-detector.test.mjs

@@ -309,7 +309,7 @@ describe("conflict-detector", () => {
 
       // Should include conflict resolution rules in final rules
       expect(result.rules).toContain("=== Conflict Resolution Guidelines ===");
-      expect(result.rules).toContain("Create layered document structure");
+      expect(result.rules).toContain("Create layered documentation structure");
       expect(result.rules).toContain("Create separate user paths");
 
       // Should also include regular configuration content with enhanced format

package/tests/utils/docs-finder-utils.test.mjs

@@ -125,7 +125,7 @@ describe("docs-finder-utils", () => {
       expect(result).toBeUndefined();
     });
 
-    test("should handle empty document structure", () => {
+    test("should handle empty documentation structure", () => {
       const result = findItemByFlatName([], "any-name");
       expect(result).toBeUndefined();
     });
@@ -243,7 +243,7 @@ describe("docs-finder-utils", () => {
       expect(result).toEqual(["guide.zh.md", "overview.zh.md"]);
     });
 
-    test("should sort files by document structure order", async () => {
+    test("should sort files by documentation structure order", async () => {
       readdirSpy.mockResolvedValue(["guide.md", "overview.md", "advanced.md"]);
 
       const documentStructure = [{ path: "/overview" }, { path: "/guide" }, { path: "/advanced" }];
@@ -253,7 +253,7 @@ describe("docs-finder-utils", () => {
       expect(result).toEqual(["overview.md", "guide.md", "advanced.md"]);
     });
 
-    test("should handle files not in document structure", async () => {
+    test("should handle files not in documentation structure", async () => {
       readdirSpy.mockResolvedValue(["guide.md", "extra.md", "overview.md"]);
 
       const documentStructure = [{ path: "/overview" }, { path: "/guide" }];
@@ -480,7 +480,7 @@ describe("docs-finder-utils", () => {
       ]);
     });
 
-    test("should warn for files not in document structure", async () => {
+    test("should warn for files not in documentation structure", async () => {
       readFileSpy.mockResolvedValue("content");
 
       const selectedFiles = ["unknown.md"];
@@ -488,7 +488,7 @@ describe("docs-finder-utils", () => {
 
       expect(result).toEqual([]);
       expect(consoleWarnSpy).toHaveBeenCalledWith(
-        "⚠️  No document structure item found for file: unknown.md",
+        "⚠️  No documentation structure item found for file: unknown.md",
       );
     });
 
@@ -508,7 +508,7 @@ describe("docs-finder-utils", () => {
         },
       ]);
       expect(consoleWarnSpy).toHaveBeenCalledWith(
-        "⚠️  No document structure item found for file: unknown.md",
+        "⚠️  No documentation structure item found for file: unknown.md",
       );
     });
 
@@ -623,14 +623,14 @@ describe("docs-finder-utils", () => {
       await expect(getMainLanguageFiles("/denied", "en")).rejects.toThrow("Permission denied");
     });
 
-    test("processSelectedFiles should handle empty document structure", async () => {
+    test("processSelectedFiles should handle empty documentation structure", async () => {
       readFileSpy.mockResolvedValue("content");
 
       const result = await processSelectedFiles(["test.md"], [], "/docs");
 
       expect(result).toEqual([]);
       expect(consoleWarnSpy).toHaveBeenCalledWith(
-        "⚠️  No document structure item found for file: test.md",
+        "⚠️  No documentation structure item found for file: test.md",
       );
     });
   });

package/types/document-structure-schema.mjs

@@ -10,7 +10,7 @@ export const documentItemSchema = z.object({
   sourceIds: z.array(z.string()).min(1, "At least one source ID is required"),
 });
 
-// Document structure schema - represents the entire document structure array
+// Documentation structure schema - represents the entire documentation structure array
 export const documentStructureSchema = z.array(documentItemSchema);
 
 // Add document schemas
@@ -80,7 +80,7 @@ export const getAddDocumentInputJsonSchema = () => {
   const schema = zodToJsonSchema(addDocumentInputSchema);
   // Add custom descriptions
   if (schema.properties) {
-    schema.properties.documentStructure.description = "Current document structure array";
+    schema.properties.documentStructure.description = "Current documentation structure array";
     schema.properties.title.description = "Title of the new document";
     schema.properties.description.description = "Description of the new document";
     schema.properties.path.description = "URL path for the new document (must start with '/')";
@@ -96,7 +96,7 @@ export const getAddDocumentOutputJsonSchema = () => {
   const schema = zodToJsonSchema(addDocumentOutputSchema);
   if (schema.properties) {
     schema.properties.documentStructure.description =
-      "Updated document structure array with the new document added";
+      "Updated documentation structure array with the new document added";
     schema.properties.addedDocument.description = "The newly added document object";
   }
   return schema;
@@ -105,7 +105,7 @@ export const getAddDocumentOutputJsonSchema = () => {
 export const getDeleteDocumentInputJsonSchema = () => {
   const schema = zodToJsonSchema(deleteDocumentInputSchema);
   if (schema.properties) {
-    schema.properties.documentStructure.description = "Current document structure array";
+    schema.properties.documentStructure.description = "Current documentation structure array";
     schema.properties.path.description = "URL path of the document to delete";
   }
   return schema;
@@ -115,7 +115,7 @@ export const getDeleteDocumentOutputJsonSchema = () => {
   const schema = zodToJsonSchema(deleteDocumentOutputSchema);
   if (schema.properties) {
     schema.properties.documentStructure.description =
-      "Updated document structure array with the document removed";
+      "Updated documentation structure array with the document removed";
     schema.properties.deletedDocument.description = "The deleted document object";
   }
   return schema;
@@ -124,7 +124,7 @@ export const getDeleteDocumentOutputJsonSchema = () => {
 export const getMoveDocumentInputJsonSchema = () => {
   const schema = zodToJsonSchema(moveDocumentInputSchema);
   if (schema.properties) {
-    schema.properties.documentStructure.description = "Current document structure array";
+    schema.properties.documentStructure.description = "Current documentation structure array";
     schema.properties.path.description = "URL path of the document to move";
     schema.properties.newParentId.description =
       "Path of the new parent document (leave empty for top-level)";
@@ -136,7 +136,7 @@ export const getMoveDocumentOutputJsonSchema = () => {
   const schema = zodToJsonSchema(moveDocumentOutputSchema);
   if (schema.properties) {
     schema.properties.documentStructure.description =
-      "Updated document structure array with the document moved";
+      "Updated documentation structure array with the document moved";
     schema.properties.originalDocument.description = "The original document object before moving";
     schema.properties.updatedDocument.description = "The updated document object after moving";
   }
@@ -146,7 +146,7 @@ export const getMoveDocumentOutputJsonSchema = () => {
 export const getUpdateDocumentInputJsonSchema = () => {
   const schema = zodToJsonSchema(updateDocumentInputSchema);
   if (schema.properties) {
-    schema.properties.documentStructure.description = "Current document structure array";
+    schema.properties.documentStructure.description = "Current documentation structure array";
     schema.properties.path.description = "URL path of the document to update";
     schema.properties.title.description = "New title for the document (optional)";
     schema.properties.description.description = "New description for the document (optional)";
@@ -166,7 +166,7 @@ export const getUpdateDocumentOutputJsonSchema = () => {
   const schema = zodToJsonSchema(updateDocumentOutputSchema);
   if (schema.properties) {
     schema.properties.documentStructure.description =
-      "Updated document structure array with the document modified";
+      "Updated documentation structure array with the document modified";
     schema.properties.originalDocument.description = "The original document object before update";
     schema.properties.updatedDocument.description =
       "The updated document object after modification";

package/utils/conflict-detector.mjs

@@ -76,7 +76,7 @@ export function getFilteredOptions(targetQuestion, currentSelections, allOptions
 }
 
 /**
- * Detect conflicts in user configuration selections that can be resolved through document structure
+ * Detect conflicts in user configuration selections that can be resolved through documentation structure
  * @param {Object} config - User configuration
  * @returns {Array} Array of detected conflicts with resolution strategies
  */