@aigne/doc-smith 0.9.7 → 0.9.8-alpha.0

package/agents/update/update-single/update-single-document-detail.mjs

@@ -4,18 +4,72 @@ import z from "zod";
 import {
   DIAGRAM_PLACEHOLDER,
   replaceD2WithPlaceholder,
-  replacePlaceholderWithD2,
+  replaceDiagramsWithPlaceholder,
 } from "../../../utils/d2-utils.mjs";
 import { userContextAt } from "../../../utils/utils.mjs";
 
 async function getIntentType(input, options) {
   const instructions = `<role>
 You are a feedback intent analyzer. Your task is to determine which type of content modifications are needed based on the user's feedback.
+
+You must analyze the user's feedback and classify it into one of the following intent types:
+- addDiagram: User wants to add a new diagram/image/chart
+- deleteDiagram: User wants to remove/delete a diagram/image/chart
+- updateDiagram: User wants to modify/update an existing diagram/image/chart
+- updateDocument: User wants to update document content (text, sections, etc.) without diagram operations
 </role>
 
+<intent_classification_rules>
+**deleteDiagram** - Use this when user explicitly wants to remove or delete a diagram/image/chart:
+- Keywords: remove, delete, 删除, 移除, 去掉, 清除
+- Combined with: diagram, image, picture, chart, graph, 图表, 图片, 图, 架构图
+- Examples:
+  - "Remove the diagram"
+  - "Delete the image"
+  - "删除这张图片"
+  - "Remove the second diagram"
+  - "去掉架构图"
+  - "Remove image from page 3"
+  - "Delete the chart showing the flow"
+
+**addDiagram** - Use this when user wants to add a new diagram:
+- Keywords: add, create, insert, 添加, 创建, 插入
+- Combined with: diagram, image, picture, chart, graph, 图表, 图片, 图
+- Examples:
+  - "Add a diagram showing the architecture"
+  - "Create a flow chart"
+  - "添加一个架构图"
+
+**updateDiagram** - Use this when user wants to modify an existing diagram:
+- Keywords: update, modify, change, improve, 更新, 修改, 改进
+- Combined with: diagram, image, picture, chart, graph, 图表, 图片, 图
+- Examples:
+  - "Update the diagram to show the new process"
+  - "Modify the chart to include more details"
+  - "更新架构图"
+
+**updateDocument** - Use this for all other content modifications:
+- Text changes, section updates, content improvements
+- No mention of diagrams/images/charts
+- Examples:
+  - "Update the introduction section"
+  - "Fix the typo in paragraph 2"
+  - "Improve the explanation"
+</intent_classification_rules>
+
 <user_feedback>
 {{feedback}}
-</user_feedback>`;
+</user_feedback>
+
+<analysis_guidelines>
+1. Pay close attention to action verbs (remove, delete, add, update, etc.)
+2. Identify the target object (diagram, image, chart, or general content)
+3. If feedback mentions removing/deleting a diagram/image/chart → deleteDiagram
+4. If feedback mentions adding a diagram/image/chart → addDiagram
+5. If feedback mentions updating a diagram/image/chart → updateDiagram
+6. If feedback is about general content without diagram references → updateDocument
+7. When in doubt, prioritize the most explicit action mentioned in the feedback
+</analysis_guidelines>`;
   const analyzeUpdateFeedbackIntentAgent = AIAgent.from({
     name: "analyzeUpdateFeedbackIntent",
     description:
@@ -43,11 +97,12 @@ You are a feedback intent analyzer. Your task is to determine which type of cont
   return intentType;
 }
 
-async function saveDoc(input, options, { content }) {
+async function saveDoc(input, options, { content, intentType }) {
   const saveAgent = options.context?.agents?.["saveDoc"];
   await options.context.invoke(saveAgent, {
     ...pick(input, ["path", "docsDir", "labels", "locale"]),
     content,
+    intentType, // Pass intentType so saveDoc can handle translation sync
   });
 }
 
@@ -56,42 +111,70 @@ async function addDiagram(input, options) {
   const currentContent = contentContext.get();
   const generateDiagramAgent = options.context.agents["checkGenerateDiagram"];
   const generateDiagramResult = await options.context.invoke(generateDiagramAgent, {
-    ...pick(input, ["locale", "path", "diagramming", "feedback"]),
+    ...pick(input, ["locale", "path", "docsDir", "diagramming", "feedback"]),
     documentContent: currentContent,
+    originalContent: currentContent,
   });
   const content = generateDiagramResult.content;
   contentContext.set(content);
-  await saveDoc(input, options, { content });
+  // Pass intentType to saveDoc so it can handle translation sync automatically
+  await saveDoc(input, options, { content, intentType: "addDiagram" });
   return { content };
 }
 
 async function updateDiagram(input, options) {
   const contentContext = userContextAt(options, `currentContents.${input.path}`);
   const currentContent = contentContext.get();
-  let [content, previousDiagramContent] = replaceD2WithPlaceholder({
+  let [content] = replaceD2WithPlaceholder({
     content: currentContent,
   });
   const generateAgent = options.context?.agents?.["generateDiagram"];
-  const { diagramSourceCode } = await options.context.invoke(generateAgent, {
+  const result = await options.context.invoke(generateAgent, {
     documentContent: content,
     locale: input.locale,
-    previousDiagramContent,
+    diagramming: input.diagramming || {},
     feedback: input.feedback,
+    originalContent: currentContent, // Pass original content to find existing diagrams
+    path: input.path,
+    docsDir: input.docsDir,
   });
-  content = replacePlaceholderWithD2({
-    content,
-    diagramSourceCode,
-  });
+
+  // generateDiagram now returns { content } with image already inserted
+  // The image replaces DIAGRAM_PLACEHOLDER or D2 code blocks
+  if (result?.content) {
+    content = result.content;
+  }
+
   contentContext.set(content);
-  await saveDoc(input, options, { content });
+  // Pass intentType to saveDoc so it can handle translation sync automatically
+  await saveDoc(input, options, { content, intentType: "updateDiagram" });
   return { content };
 }
 
 async function deleteDiagram(input, options) {
   const contentContext = userContextAt(options, `currentContents.${input.path}`);
   const currentContent = contentContext.get();
-  const [documentContent] = replaceD2WithPlaceholder({
+
+  // Extract diagram index from feedback if provided
+  // This allows deleting a specific diagram when multiple diagrams exist
+  let diagramIndex = input.diagramIndex;
+  if (diagramIndex === undefined && input.feedback) {
+    // Import extractDiagramIndexFromFeedback from replace-d2-with-image.mjs
+    const { extractDiagramIndexFromFeedback } = await import(
+      "../../create/replace-d2-with-image.mjs"
+    );
+    const extractedIndex = extractDiagramIndexFromFeedback(input.feedback);
+    if (extractedIndex !== null) {
+      diagramIndex = extractedIndex;
+    }
+  }
+
+  // Replace all diagrams (D2 code blocks, generated images, Mermaid) with placeholder
+  // If diagramIndex is provided, only replace that specific diagram
+  // This ensures LLM can identify and remove the diagram regardless of its type
+  const documentContent = replaceDiagramsWithPlaceholder({
     content: currentContent,
+    diagramIndex,
   });
   const instructions = `<role>
 Your task is to remove ${DIAGRAM_PLACEHOLDER} and adjust the document context (based on the user's feedback) to make it easier to understand.
@@ -123,8 +206,24 @@ Your task is to remove ${DIAGRAM_PLACEHOLDER} and adjust the document context (b
     documentContent,
     feedback: input.feedback,
   });
+
+  // Delete associated diagram image files
+  if (input.docsDir) {
+    try {
+      const { deleteDiagramImages } = await import("../../../utils/delete-diagram-images.mjs");
+      const { deleted } = await deleteDiagramImages(currentContent, input.path, input.docsDir);
+      if (deleted > 0) {
+        console.log(`Deleted ${deleted} diagram image file(s) for ${input.path}`);
+      }
+    } catch (error) {
+      // Don't fail the operation if image deletion fails
+      console.warn(`Failed to delete diagram images: ${error.message}`);
+    }
+  }
+
   contentContext.set(content);
-  await saveDoc(input, options, { content });
+  // Pass intentType to saveDoc so it can handle translation sync automatically
+  await saveDoc(input, options, { content, intentType: "deleteDiagram" });
 
   return { content };
 }
@@ -149,7 +248,19 @@ async function updateDocument(input, options) {
 }
 
 export default async function updateSingleDocumentDetail(input, options) {
-  const intentType = await getIntentType(input, options);
+  // Use intentType from input if available (analyzed in parent flow),
+  // otherwise fall back to analyzing it here (for backward compatibility)
+  let intentType = input.intentType;
+  if (!intentType && input.feedback) {
+    intentType = await getIntentType(input, options);
+  }
+
+  // If intentType is still null or undefined, default to updateDocument
+  // This ensures that some operation is always performed, even if intent analysis failed
+  // or no explicit intent was provided
+  if (!intentType) {
+    intentType = "updateDocument";
+  }
 
   const fnMap = {
     addDiagram,
@@ -162,5 +273,8 @@ export default async function updateSingleDocumentDetail(input, options) {
     const result = await fnMap[intentType](input, options);
     return result;
   }
-  return {};
+
+  // Fallback: if intentType is not in fnMap, default to updateDocument
+  console.warn(`Unknown intentType: ${intentType}, defaulting to updateDocument`);
+  return await updateDocument(input, options);
 }

package/agents/utils/analyze-feedback-intent.mjs

@@ -0,0 +1,136 @@
+import { AIAgent } from "@aigne/core";
+import z from "zod";
+
+/**
+ * Analyze user feedback to determine the intent type for document updates
+ * Returns one of: "addDiagram", "deleteDiagram", "updateDiagram", "updateDocument"
+ * Returns null if feedback is empty or invalid
+ */
+export default async function analyzeFeedbackIntent({ feedback, shouldUpdateDiagrams }, options) {
+  // Check if feedback exists and is not empty
+  // If feedback is empty and --diagram flag is set, default to updateDiagram
+  // Otherwise return null
+  if (!feedback || typeof feedback !== "string" || !feedback.trim()) {
+    // If --diagram flag is set, default to updateDiagram (user wants to update diagrams)
+    if (shouldUpdateDiagrams) {
+      return { intentType: "updateDiagram" };
+    }
+    return { intentType: null };
+  }
+
+  // Always analyze user feedback first, even if --diagram flag is set
+  // This ensures user's explicit intent (e.g., "remove image", "delete diagram") is respected
+  // The --diagram flag should only be a hint, not override explicit user commands
+
+  const instructions = `<role>
+You are a feedback intent analyzer. Your task is to determine which type of content modifications are needed based on the user's feedback.
+
+You must analyze the user's feedback and classify it into one of the following intent types:
+- addDiagram: User wants to add a new diagram/image/chart
+- deleteDiagram: User wants to remove/delete a diagram/image/chart
+- updateDiagram: User wants to modify/update an existing diagram/image/chart
+- updateDocument: User wants to update document content (text, sections, etc.) without diagram operations
+</role>
+
+<intent_classification_rules>
+**deleteDiagram** - Use this when user explicitly wants to remove or delete a diagram/image/chart:
+- Keywords: remove, delete, 删除, 移除, 去掉, 清除
+- Combined with: diagram, image, picture, chart, graph, 图表, 图片, 图, 架构图
+- Examples:
+  - "Remove the diagram"
+  - "Delete the image"
+  - "删除这张图片"
+  - "Remove the second diagram"
+  - "去掉架构图"
+  - "Remove image from page 3"
+  - "Delete the chart showing the flow"
+
+**addDiagram** - Use this when user wants to add a new diagram:
+- Keywords: add, create, insert, 添加, 创建, 插入
+- Combined with: diagram, image, picture, chart, graph, 图表, 图片, 图
+- Examples:
+  - "Add a diagram showing the architecture"
+  - "Create a flow chart"
+  - "添加一个架构图"
+
+**updateDiagram** - Use this when user wants to modify an existing diagram:
+- Keywords: update, modify, change, improve, 更新, 修改, 改进
+- Combined with: diagram, image, picture, chart, graph, 图表, 图片, 图
+- Examples:
+  - "Update the diagram to show the new process"
+  - "Modify the chart to include more details"
+  - "更新架构图"
+
+**updateDocument** - Use this for all other content modifications:
+- Text changes, section updates, content improvements
+- No mention of diagrams/images/charts
+- Examples:
+  - "Update the introduction section"
+  - "Fix the typo in paragraph 2"
+  - "Improve the explanation"
+</intent_classification_rules>
+
+<user_feedback>
+{{feedback}}
+</user_feedback>
+
+<analysis_guidelines>
+1. Pay close attention to action verbs (remove, delete, add, update, etc.)
+2. Identify the target object (diagram, image, chart, or general content)
+3. If feedback mentions removing/deleting a diagram/image/chart → deleteDiagram
+4. If feedback mentions adding a diagram/image/chart → addDiagram
+5. If feedback mentions updating a diagram/image/chart → updateDiagram
+6. If feedback is about general content without diagram references → updateDocument
+7. When in doubt, prioritize the most explicit action mentioned in the feedback
+</analysis_guidelines>`;
+
+  try {
+    const analyzeUpdateFeedbackIntentAgent = AIAgent.from({
+      name: "analyzeUpdateFeedbackIntent",
+      description:
+        "Analyze user feedback to determine if document are needed for content modifications",
+      task_render_mode: "hide",
+      instructions,
+      inputSchema: z.object({
+        feedback: z.string().describe("User feedback for content modifications"),
+      }),
+      outputSchema: z.object({
+        intentType: z
+          .enum(["addDiagram", "deleteDiagram", "updateDiagram", "updateDocument"])
+          .describe(
+            "The primary type of user intention: one of addDiagram, deleteDiagram, updateDiagram, updateDocument",
+          ),
+      }),
+    });
+
+    const { intentType } = await options.context.invoke(analyzeUpdateFeedbackIntentAgent, {
+      feedback: feedback.trim(),
+    });
+
+    // If --diagram flag is set and user didn't explicitly request delete/add,
+    // default to updateDiagram (for backward compatibility)
+    // But if user explicitly requested delete/add, respect that intent
+    if (
+      shouldUpdateDiagrams &&
+      intentType &&
+      !["deleteDiagram", "addDiagram"].includes(intentType)
+    ) {
+      return { intentType: "updateDiagram" };
+    }
+
+    return { intentType };
+  } catch (error) {
+    // If analysis fails and --diagram flag is set, default to updateDiagram
+    // Otherwise return null to fall back to default document update flow
+    if (shouldUpdateDiagrams) {
+      console.warn(
+        `Failed to analyze feedback intent, defaulting to updateDiagram due to --diagram flag: ${error.message}`,
+      );
+      return { intentType: "updateDiagram" };
+    }
+    console.warn(`Failed to analyze feedback intent: ${error.message}`);
+    return { intentType: null };
+  }
+}
+
+analyzeFeedbackIntent.task_render_mode = "hide";

package/agents/utils/choose-docs.mjs

@@ -5,7 +5,15 @@ import {
   getActionText,
   getMainLanguageFiles,
   processSelectedFiles,
+  readFileContent,
 } from "../../utils/docs-finder-utils.mjs";
+import {
+  hasDiagramContent,
+  hasBananaImages,
+  getDiagramTypeLabels,
+  formatDiagramTypeSuffix,
+} from "../../utils/check-document-has-diagram.mjs";
+import { debug } from "../../utils/debug.mjs";
 import { DOC_ACTION } from "../../utils/constants/index.mjs";
 
 function getFeedbackMessage(action) {
@@ -27,6 +35,10 @@ export default async function chooseDocs(
     reset = false,
     requiredFeedback = true,
     action,
+    shouldUpdateDiagrams = false,
+    shouldAutoSelectDiagrams = false,
+    shouldSyncImages = false,
+    ...rest
   },
   options,
 ) {
@@ -48,55 +60,181 @@ export default async function chooseDocs(
         );
       }
 
-      // Convert files to choices with titles
-      const choices = mainLanguageFiles.map((file) => {
-        // Convert filename to flat path to find corresponding documentation structure item
-        const flatName = file.replace(/\.md$/, "").replace(/\.\w+(-\w+)?$/, "");
-        const docItem = documentStructure.find((item) => {
-          const itemFlattenedPath = item.path.replace(/^\//, "").replace(/\//g, "-");
-          return itemFlattenedPath === flatName;
-        });
+      // If --diagram-sync flag is set, filter documents by banana images only
+      if (shouldSyncImages) {
+        debug("🔄 Filtering documents with banana images...");
 
-        // Use title if available, otherwise fall back to filename
-        let displayName = docItem?.title;
-        if (displayName) {
-          displayName = `${displayName} (${file})`;
-        } else {
-          displayName = file;
+        // Read content for all files and filter by banana images only
+        const filesWithImages = [];
+        for (const fileName of mainLanguageFiles) {
+          const content = await readFileContent(docsDir, fileName);
+          if (content && hasBananaImages(content)) {
+            filesWithImages.push(fileName);
+          }
         }
 
-        return {
-          name: displayName,
-          value: file,
-        };
-      });
+        if (filesWithImages.length === 0) {
+          debug("ℹ️  No documents found with banana images (DIAGRAM_IMAGE_START markers).");
+          return {
+            selectedDocs: [],
+            feedback: "",
+            selectedPaths: [],
+          };
+        }
+
+        debug(`✅ Found ${filesWithImages.length} document(s) with banana images.`);
+        debug("📋 Auto-selecting all documents with banana images...");
+        // Show diagram types for each document
+        for (const file of filesWithImages) {
+          const content = await readFileContent(docsDir, file);
+          const diagramLabels = content ? getDiagramTypeLabels(content) : [];
+          const diagramSuffix = formatDiagramTypeSuffix(diagramLabels);
+          debug(`   • ${file}${diagramSuffix}`);
+        }
+        selectedFiles = filesWithImages;
+      }
+      // If --diagram flag is set, filter documents by diagram content
+      else if (shouldUpdateDiagrams) {
+        debug("🔄 Filtering documents with diagram content...");
 
-      // Let user select multiple files
-      selectedFiles = await options.prompts.checkbox({
-        message: getActionText("Select documents to {action}:", docAction),
-        source: (term) => {
-          if (!term) return choices;
-
-          return choices.filter((choice) => choice.name.toLowerCase().includes(term.toLowerCase()));
-        },
-        validate: (answer) => {
-          if (answer.length === 0) {
-            return "Please select at least one document";
+        // Read content for all files and filter by diagram content
+        const filesWithDiagrams = [];
+        for (const fileName of mainLanguageFiles) {
+          const content = await readFileContent(docsDir, fileName);
+          if (content && hasDiagramContent(content)) {
+            filesWithDiagrams.push(fileName);
           }
-          return true;
-        },
-      });
+        }
+
+        if (filesWithDiagrams.length === 0) {
+          debug(
+            "ℹ️  No documents found with diagram content (d2 code blocks, placeholders, or diagram images).",
+          );
+          return {
+            selectedDocs: [],
+            feedback: "",
+            selectedPaths: [],
+          };
+        }
+
+        debug(`✅ Found ${filesWithDiagrams.length} document(s) with diagram content.`);
+
+        // If --diagram-all, auto-select all; otherwise let user choose
+        if (shouldAutoSelectDiagrams) {
+          debug("📋 Auto-selecting all documents with diagrams...");
+          // Show diagram types for each document in auto-select mode
+          for (const file of filesWithDiagrams) {
+            const content = await readFileContent(docsDir, file);
+            const diagramLabels = content ? getDiagramTypeLabels(content) : [];
+            const diagramSuffix = formatDiagramTypeSuffix(diagramLabels);
+            debug(`   • ${file}${diagramSuffix}`);
+          }
+          selectedFiles = filesWithDiagrams;
+        } else {
+          // --diagram mode: show only documents with diagrams, let user select
+          const choices = await Promise.all(
+            filesWithDiagrams.map(async (file) => {
+              // Convert filename to flat path to find corresponding documentation structure item
+              const flatName = file.replace(/\.md$/, "").replace(/\.\w+(-\w+)?$/, "");
+              const docItem = documentStructure.find((item) => {
+                const itemFlattenedPath = item.path.replace(/^\//, "").replace(/\//g, "-");
+                return itemFlattenedPath === flatName;
+              });
 
-      if (!selectedFiles || selectedFiles.length === 0) {
-        throw new Error("No documents selected");
+              // Read content to detect diagram types
+              const content = await readFileContent(docsDir, file);
+              const diagramLabels = content ? getDiagramTypeLabels(content) : [];
+              const diagramSuffix = formatDiagramTypeSuffix(diagramLabels);
+
+              // Use title if available, otherwise fall back to filename
+              let displayName = docItem?.title;
+              if (displayName) {
+                displayName = `${displayName} (${file})${diagramSuffix}`;
+              } else {
+                displayName = `${file}${diagramSuffix}`;
+              }
+
+              return {
+                name: displayName,
+                value: file,
+              };
+            }),
+          );
+
+          // Let user select multiple files from filtered list
+          selectedFiles = await options.prompts.checkbox({
+            message: getActionText("Select documents with diagrams to {action}:", docAction),
+            source: (term) => {
+              if (!term) return choices;
+
+              return choices.filter((choice) =>
+                choice.name.toLowerCase().includes(term.toLowerCase()),
+              );
+            },
+            validate: (answer) => {
+              if (answer.length === 0) {
+                return "Please select at least one document";
+              }
+              return true;
+            },
+          });
+
+          if (!selectedFiles || selectedFiles.length === 0) {
+            throw new Error("No documents selected");
+          }
+        }
+      } else {
+        // Normal flow: let user select documents from all files
+        // Convert files to choices with titles
+        const choices = mainLanguageFiles.map((file) => {
+          // Convert filename to flat path to find corresponding documentation structure item
+          const flatName = file.replace(/\.md$/, "").replace(/\.\w+(-\w+)?$/, "");
+          const docItem = documentStructure.find((item) => {
+            const itemFlattenedPath = item.path.replace(/^\//, "").replace(/\//g, "-");
+            return itemFlattenedPath === flatName;
+          });
+
+          // Use title if available, otherwise fall back to filename
+          let displayName = docItem?.title;
+          if (displayName) {
+            displayName = `${displayName} (${file})`;
+          } else {
+            displayName = file;
+          }
+
+          return {
+            name: displayName,
+            value: file,
+          };
+        });
+
+        // Let user select multiple files
+        selectedFiles = await options.prompts.checkbox({
+          message: getActionText("Select documents to {action}:", docAction),
+          source: (term) => {
+            if (!term) return choices;
+
+            return choices.filter((choice) =>
+              choice.name.toLowerCase().includes(term.toLowerCase()),
+            );
+          },
+          validate: (answer) => {
+            if (answer.length === 0) {
+              return "Please select at least one document";
+            }
+            return true;
+          },
+        });
+
+        if (!selectedFiles || selectedFiles.length === 0) {
+          throw new Error("No documents selected");
+        }
       }
 
       // Process selected files and convert to found items
       foundItems = await processSelectedFiles(selectedFiles, documentStructure, docsDir);
     } catch (error) {
-      console.log(
-        getActionText(`\nFailed to select documents to {action}: ${error.message}`, docAction),
-      );
+      debug(getActionText(`\nFailed to select documents to {action}: ${error.message}`, docAction));
       process.exit(0);
     }
   } else {
@@ -105,7 +243,7 @@ export default async function chooseDocs(
       const foundItem = await findItemByPath(documentStructure, docPath, boardId, docsDir, locale);
 
       if (!foundItem) {
-        console.warn(`⚠️  Item with path "${docPath}" not found in documentStructure`);
+        debug(`⚠️  Item with path "${docPath}" not found in documentStructure`);
         continue;
       }
 
@@ -120,8 +258,15 @@ export default async function chooseDocs(
   }
 
   // Prompt for feedback if not provided
+  // Skip feedback prompt if --diagram, --diagram-all, or --diagram-sync flag is set
   let userFeedback = feedback;
-  if (!userFeedback && (requiredFeedback || foundItems?.length > 1)) {
+  if (
+    !userFeedback &&
+    (requiredFeedback || foundItems?.length > 1) &&
+    !shouldUpdateDiagrams &&
+    !shouldSyncImages &&
+    !rest.isChat
+  ) {
     const feedbackMessage = getFeedbackMessage(docAction);
 
     userFeedback = await options.prompts.input({

package/agents/utils/generate-document-or-skip.mjs

@@ -0,0 +1,41 @@
+/**
+ * Conditionally call generateDocument. If we already have content for diagram-only intents,
+ * skip LLM generation and pass through the existing content.
+ */
+export default async function generateDocumentOrSkip(input, options) {
+  const { intentType, content, skipGenerateDocument } = input;
+
+  const isDiagramIntent =
+    intentType && ["addDiagram", "updateDiagram", "deleteDiagram"].includes(intentType);
+  const shouldSkip = Boolean(skipGenerateDocument || (isDiagramIntent && content));
+
+  if (shouldSkip) {
+    // Return the existing content and mark the generation as skipped
+    return {
+      ...input,
+      content,
+      documentContent: content,
+      originalContent: content,
+      reviewContent: content,
+    };
+  }
+
+  const generateAgent = options.context?.agents?.["generateDocument"];
+  if (!generateAgent) {
+    throw new Error("generateDocument agent not found");
+  }
+
+  const result = await options.context.invoke(generateAgent, input);
+  const generatedContent = result?.content ?? result;
+
+  return {
+    ...input,
+    ...result,
+    content: generatedContent,
+    documentContent: generatedContent,
+    originalContent: generatedContent,
+    reviewContent: generatedContent,
+  };
+}
+
+generateDocumentOrSkip.task_render_mode = "hide";