@aigne/doc-smith 0.8.11-beta → 0.8.11-beta.2

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

@@ -0,0 +1,82 @@
+import {
+  getMoveDocumentInputJsonSchema,
+  getMoveDocumentOutputJsonSchema,
+  validateMoveDocumentInput,
+} from "../../../types/document-structure-schema.mjs";
+
+export default async function moveDocument(input) {
+  // Validate input using Zod schema
+  const validation = validateMoveDocumentInput(input);
+  if (!validation.success) {
+    console.log(`Error: Cannot move document - ${validation.error}`);
+    return { documentStructure: input.documentStructure };
+  }
+
+  const { documentStructure, path, newParentId } = validation.data;
+
+  // Find the document to move
+  const documentIndex = documentStructure.findIndex((item) => item.path === path);
+  if (documentIndex === -1) {
+    console.log(
+      `Error: Cannot move document - Document '${path}' does not exist. Please select an existing document to move.`,
+    );
+    return { documentStructure };
+  }
+
+  const documentToMove = documentStructure[documentIndex];
+
+  // Validate new parent exists if newParentId is provided
+  if (
+    newParentId !== null &&
+    newParentId !== undefined &&
+    newParentId !== "null" &&
+    newParentId !== ""
+  ) {
+    const newParentExists = documentStructure.some((item) => item.path === newParentId);
+    if (!newParentExists) {
+      console.log(
+        `Error: Cannot move document - Target parent document '${newParentId}' does not exist. Please select an existing parent document.`,
+      );
+      return { documentStructure };
+    }
+
+    // Check for circular dependency: the new parent cannot be a descendant of the document being moved
+    const isDescendant = (parentPath, childPath) => {
+      const children = documentStructure.filter((item) => item.parentId === parentPath);
+      for (const child of children) {
+        if (child.path === childPath || isDescendant(child.path, childPath)) {
+          return true;
+        }
+      }
+      return false;
+    };
+
+    if (isDescendant(path, newParentId)) {
+      console.log(
+        `Error: Cannot move document - Moving '${path}' under '${newParentId}' would create an invalid hierarchy. Please select a parent that is not nested under the document being moved.`,
+      );
+      return { documentStructure };
+    }
+  }
+
+  // Create updated document object with new parent
+  const updatedDocument = {
+    ...documentToMove,
+    parentId: newParentId || null,
+  };
+
+  // Update the document structure
+  const updatedStructure = [...documentStructure];
+  updatedStructure[documentIndex] = updatedDocument;
+
+  return {
+    documentStructure: updatedStructure,
+    originalDocument: documentToMove,
+    updatedDocument,
+  };
+}
+
+moveDocument.taskTitle = "Move document";
+moveDocument.description = "Move a document to a different parent in the document structure";
+moveDocument.inputSchema = getMoveDocumentInputJsonSchema();
+moveDocument.outputSchema = getMoveDocumentOutputJsonSchema();

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

@@ -0,0 +1,50 @@
+import {
+  getUpdateDocumentInputJsonSchema,
+  getUpdateDocumentOutputJsonSchema,
+  validateUpdateDocumentInput,
+} from "../../../types/document-structure-schema.mjs";
+
+export default async function updateDocument(input) {
+  // Validate input using Zod schema
+  const validation = validateUpdateDocumentInput(input);
+  if (!validation.success) {
+    console.log(`⚠️  Cannot update document: ${validation.error}`);
+    return { documentStructure: input.documentStructure };
+  }
+
+  const { documentStructure, path, title, description, sourceIds } = validation.data;
+
+  // Find the document to update
+  const documentIndex = documentStructure.findIndex((item) => item.path === path);
+  if (documentIndex === -1) {
+    console.log(
+      `⚠️  Cannot update document: Document '${path}' does not exist. Choose an existing document to update.`,
+    );
+    return { documentStructure };
+  }
+
+  const originalDocument = documentStructure[documentIndex];
+
+  // Create updated document object
+  const updatedDocument = {
+    ...originalDocument,
+    ...(title !== undefined && { title }),
+    ...(description !== undefined && { description }),
+    ...(sourceIds !== undefined && { sourceIds: [...sourceIds] }), // Create a copy of the array
+  };
+
+  // Update the document structure
+  const updatedStructure = [...documentStructure];
+  updatedStructure[documentIndex] = updatedDocument;
+
+  return {
+    documentStructure: updatedStructure,
+    originalDocument,
+    updatedDocument,
+  };
+}
+
+updateDocument.taskTitle = "Update document";
+updateDocument.description = "Update properties of an existing document in the document structure";
+updateDocument.inputSchema = getUpdateDocumentInputJsonSchema();
+updateDocument.outputSchema = getUpdateDocumentOutputJsonSchema();

package/agents/generate/generate-structure.yaml

@@ -1,7 +1,7 @@
 name: generateStructure
 description: Generate the structure and organization of your documentation
 instructions:
-  url: ../../prompts/structure/generate-structure.md
+  url: ../../prompts/structure/generate-structure-system.md
 input_schema:
   type: object
   properties:

package/agents/generate/update-document-structure.yaml

@@ -0,0 +1,42 @@
+type: ai
+name: updateDocumentStructure
+description: Update document structure based on user feedback and intentions using structure modification tools
+instructions:
+  url: ../../prompts/structure/update-document-structure.md
+input_schema:
+  type: object
+  properties:
+    documentStructure: ../schema/document-structure.yaml
+    rules:
+      type: string
+      description: User configuration rules
+    locale:
+      type: string
+      description: User language, e.g. zh, en
+    datasources:
+      type: string
+      description: Context for document structure
+    glossary:
+      type: string
+      description: Glossary of terms
+    feedback:
+      type: string
+      description: User feedback for structure modifications
+    userPreferences:
+      type: string
+      description: Your saved preferences for structure and documentation style
+  required:
+    - documentStructure
+    - feedback
+output_schema:
+  type: object
+  properties:
+    documentStructure: ../schema/document-structure.yaml
+    operationSummary:
+      type: string
+      description: Summary of the operations performed on the document structure
+skills:
+  - ./document-structure-tools/add-document.mjs
+  - ./document-structure-tools/delete-document.mjs
+  - ./document-structure-tools/update-document.mjs
+  - ./document-structure-tools/move-document.mjs

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

@@ -56,7 +56,9 @@ function printDocumentStructure(structure) {
   if (rootNodes.length === 0) {
     console.log("  No document structure found.");
   } else {
-    rootNodes.forEach((node) => printNode(node));
+    rootNodes.forEach((node) => {
+      printNode(node);
+    });
   }
   console.log();
 }
@@ -112,10 +114,10 @@ export default async function userReviewDocumentStructure({ documentStructure, .
     }
 
     // Get the refineDocumentStructure agent
-    const refineAgent = options.context.agents["refineDocumentStructure"];
+    const refineAgent = options.context.agents["updateDocumentStructure"];
     if (!refineAgent) {
       console.log(
-        "Unable to process your feedback - the structure refinement feature is unavailable.",
+        "Unable to process your feedback - the document structure update feature is unavailable.",
       );
       console.log("Please try again later or contact support if this continues.");
       break;
@@ -133,7 +135,7 @@ export default async function userReviewDocumentStructure({ documentStructure, .
       const result = await options.context.invoke(refineAgent, {
         ...rest,
         feedback: feedback.trim(),
-        originalDocumentStructure: currentStructure,
+        documentStructure: currentStructure,
         userPreferences,
       });
 

package/agents/init/index.mjs

@@ -11,7 +11,7 @@ import {
   READER_KNOWLEDGE_LEVELS,
   SUPPORTED_LANGUAGES,
   TARGET_AUDIENCES,
-} from "../../utils/constants.mjs";
+} from "../../utils/constants/index.mjs";
 import loadConfig from "../../utils/load-config.mjs";
 import {
   detectSystemLanguage,

package/agents/publish/publish-docs.mjs

@@ -5,7 +5,7 @@ import chalk from "chalk";
 import fs from "fs-extra";
 
 import { getAccessToken } from "../../utils/auth-utils.mjs";
-import { DISCUSS_KIT_STORE_URL, TMP_DIR, TMP_DOCS_DIR } from "../../utils/constants.mjs";
+import { DISCUSS_KIT_STORE_URL, TMP_DIR, TMP_DOCS_DIR } from "../../utils/constants/index.mjs";
 import { beforePublishHook, ensureTmpDir } from "../../utils/d2-utils.mjs";
 import { deploy } from "../../utils/deploy.mjs";
 import { getGithubRepoUrl, loadConfigFromFile, saveValueToConfig } from "../../utils/utils.mjs";
@@ -153,7 +153,11 @@ export default async function publishDocs(
   let message;
 
   try {
-    const { success, boardId: newBoardId } = await publishDocsFn({
+    const {
+      success,
+      boardId: newBoardId,
+      error,
+    } = await publishDocsFn({
       sidebarPath,
       accessToken,
       appUrl,
@@ -179,7 +183,12 @@ export default async function publishDocs(
       if (boardId !== newBoardId) {
         await saveValueToConfig("boardId", newBoardId);
       }
-      message = `✅ Documentation Published Successfully!`;
+      message = `✅ Documentation published successfully!`;
+    } else {
+      // If the error is 401 or 403, it means the access token is invalid
+      if (error?.includes("401") || error?.includes("403")) {
+        message = `❌ Publishing failed: you don’t have valid authorization.\n   Run ${chalk.cyan("aigne doc clear")} to reset it, then publish again.`;
+      }
     }
   } catch (error) {
     message = `❌ Failed to publish docs: ${error.message}`;

package/agents/translate/choose-language.mjs

@@ -1,4 +1,4 @@
-import { SUPPORTED_LANGUAGES } from "../../utils/constants.mjs";
+import { SUPPORTED_LANGUAGES } from "../../utils/constants/index.mjs";
 import { loadConfigFromFile, saveValueToConfig } from "../../utils/utils.mjs";
 
 /**

package/agents/update/batch-update-document.yaml

@@ -0,0 +1,7 @@
+
+type: team
+name: batchUpdateDocument
+skills:
+  - ../update/generate-and-translate-document.yaml
+iterate_on: selectedDocs
+concurrency: 5

package/agents/update/check-update-is-single.mjs

@@ -0,0 +1,38 @@
+export default async function checkUpdateIsSingle({ selectedDocs, ...rest }, options) {
+  if (!selectedDocs || !Array.isArray(selectedDocs)) {
+    throw new Error("selectedDocs must be provided as an array");
+  }
+
+  if (selectedDocs.length === 0) {
+    throw new Error("selectedDocs cannot be empty");
+  }
+
+  let targetAgent;
+  let agentName;
+
+  if (selectedDocs.length === 1) {
+    agentName = "updateSingleDocument";
+    targetAgent = options.context.agents["updateSingleDocument"];
+  } else {
+    agentName = "batchUpdateDocument";
+    targetAgent = options.context.agents["batchUpdateDocument"];
+  }
+
+  if (!targetAgent) {
+    throw new Error(`Agent "${agentName}" is not available`);
+  }
+
+  try {
+    const result = await options.context.invoke(targetAgent, {
+      selectedDocs,
+      ...rest,
+    });
+
+    return result;
+  } catch (error) {
+    console.error(`Error invoking ${agentName}:`, error.message);
+    throw error;
+  }
+}
+
+checkUpdateIsSingle.taskTitle = "Check document count and route to appropriate update agent";

package/agents/update/document-tools/update-document-content.mjs

@@ -0,0 +1,293 @@
+import { applyPatch } from "diff";
+import {
+  getUpdateDocumentContentInputJsonSchema,
+  getUpdateDocumentContentOutputJsonSchema,
+  validateUpdateDocumentContentInput,
+} from "../../../types/document-schema.mjs";
+
+export default async function updateDocumentContent(input) {
+  // Validate input using Zod schema
+  const validation = validateUpdateDocumentContentInput(input);
+  if (!validation.success) {
+    return {
+      success: false,
+      error: validation.error,
+      message: "Invalid input parameters",
+    };
+  }
+
+  const { originalContent, diffPatch } = validation.data;
+
+  try {
+    // Parse and validate diff patch
+    const parsedDiff = parseDiffPatch(diffPatch);
+    if (!parsedDiff.success) {
+      return {
+        success: false,
+        error: parsedDiff.error,
+        message: "Invalid diff format: No valid hunks found or parsing failed",
+      };
+    }
+
+    // Check and fix line number issues
+    const fixedDiff = fixLineNumberIssues(originalContent, parsedDiff.hunks);
+    if (!fixedDiff.success) {
+      return {
+        success: false,
+        error: fixedDiff.error,
+        message: "Cannot fix diff line number issues",
+      };
+    }
+
+    // Reconstruct the fixed diff patch
+    const fixedPatch = reconstructDiffPatch(fixedDiff.hunks);
+
+    // Apply the diff patch using the diff library
+    const result = applyPatch(originalContent, fixedPatch);
+
+    if (result === false) {
+      return {
+        success: false,
+        error: "Failed to apply patch",
+        message: "Diff patch could not be applied",
+      };
+    }
+
+    return {
+      success: true,
+      updatedContent: result,
+      message: "Document content updated successfully",
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message,
+      message: "Failed to update document content",
+    };
+  }
+}
+
+function parseDiffPatch(diffPatch) {
+  try {
+    const hunks = [];
+    const lines = diffPatch.split("\n");
+    let currentHunk = null;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Parse hunk header: @@ -oldStart,oldCount +newStart,newCount @@
+      const hunkMatch = line.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
+      if (hunkMatch) {
+        if (currentHunk) {
+          hunks.push(currentHunk);
+        }
+        currentHunk = {
+          oldStart: parseInt(hunkMatch[1], 10),
+          oldCount: parseInt(hunkMatch[2], 10) || 1,
+          newStart: parseInt(hunkMatch[3], 10),
+          newCount: parseInt(hunkMatch[4], 10) || 1,
+          changes: [],
+        };
+        continue;
+      }
+
+      // Parse changes
+      if (currentHunk && line.length > 0) {
+        const changeType = line[0];
+        const content = line.slice(1);
+
+        if (changeType === "-") {
+          currentHunk.changes.push({ type: "remove", content });
+        } else if (changeType === "+") {
+          currentHunk.changes.push({ type: "add", content });
+        } else if (changeType === " ") {
+          currentHunk.changes.push({ type: "context", content });
+        }
+      }
+    }
+
+    if (currentHunk) {
+      hunks.push(currentHunk);
+    }
+
+    if (hunks.length === 0) {
+      return { success: false, error: "No valid hunks found in diff" };
+    }
+
+    return { success: true, hunks };
+  } catch (error) {
+    return { success: false, error: `Failed to parse diff: ${error.message}` };
+  }
+}
+
+function fixLineNumberIssues(originalContent, hunks) {
+  try {
+    const originalLines = originalContent.split("\n");
+    const fixedHunks = [];
+
+    for (const hunk of hunks) {
+      // Extract context and removed lines to find best match
+      const contextAndRemoved = hunk.changes
+        .filter((change) => change.type === "context" || change.type === "remove")
+        .map((change) => change.content);
+
+      if (contextAndRemoved.length === 0) {
+        // No context to match against, keep original
+        fixedHunks.push(hunk);
+        continue;
+      }
+
+      // Find best matching position in original content
+      const bestMatch = findBestMatch(originalLines, contextAndRemoved, hunk.oldStart - 1);
+
+      if (bestMatch.found) {
+        const fixedHunk = {
+          ...hunk,
+          oldStart: bestMatch.position + 1,
+          newStart: bestMatch.position + 1,
+          // Fix line counts based on actual changes
+          oldCount: calculateOldCount(hunk.changes),
+          newCount: calculateNewCount(hunk.changes),
+        };
+        fixedHunks.push(fixedHunk);
+      } else {
+        // Try fuzzy matching
+        const fuzzyMatch = findFuzzyMatch(originalLines, contextAndRemoved);
+        if (fuzzyMatch.found) {
+          const fixedHunk = {
+            ...hunk,
+            oldStart: fuzzyMatch.position + 1,
+            newStart: fuzzyMatch.position + 1,
+            // Fix line counts based on actual changes
+            oldCount: calculateOldCount(hunk.changes),
+            newCount: calculateNewCount(hunk.changes),
+          };
+          fixedHunks.push(fixedHunk);
+        } else {
+          return {
+            success: false,
+            error: `Cannot find matching context for hunk at line ${hunk.oldStart}`,
+          };
+        }
+      }
+    }
+
+    return { success: true, hunks: fixedHunks };
+  } catch (error) {
+    return { success: false, error: `Failed to fix line numbers: ${error.message}` };
+  }
+}
+
+function findBestMatch(originalLines, targetLines, startPosition) {
+  // Try exact match at expected position first
+  if (startPosition >= 0 && startPosition + targetLines.length <= originalLines.length) {
+    let matches = 0;
+    for (let i = 0; i < targetLines.length; i++) {
+      if (originalLines[startPosition + i] === targetLines[i]) {
+        matches++;
+      }
+    }
+
+    if (matches === targetLines.length) {
+      return { found: true, position: startPosition };
+    }
+  }
+
+  // Try nearby positions (within 10 lines)
+  const NEARBY_SEARCH_RANGE = 10; // Maximum number of lines to search before/after expected position
+  for (let offset = 1; offset <= NEARBY_SEARCH_RANGE; offset++) {
+    // Try before
+    const beforePos = startPosition - offset;
+    if (beforePos >= 0 && beforePos + targetLines.length <= originalLines.length) {
+      let matches = 0;
+      for (let i = 0; i < targetLines.length; i++) {
+        if (originalLines[beforePos + i] === targetLines[i]) {
+          matches++;
+        }
+      }
+      if (matches === targetLines.length) {
+        return { found: true, position: beforePos };
+      }
+    }
+
+    // Try after
+    const afterPos = startPosition + offset;
+    if (afterPos >= 0 && afterPos + targetLines.length <= originalLines.length) {
+      let matches = 0;
+      for (let i = 0; i < targetLines.length; i++) {
+        if (originalLines[afterPos + i] === targetLines[i]) {
+          matches++;
+        }
+      }
+      if (matches === targetLines.length) {
+        return { found: true, position: afterPos };
+      }
+    }
+  }
+
+  return { found: false };
+}
+
+function findFuzzyMatch(originalLines, targetLines) {
+  // Find the best partial match
+  let bestMatch = { found: false, position: 0, score: 0 };
+
+  for (let pos = 0; pos <= originalLines.length - targetLines.length; pos++) {
+    let matches = 0;
+    for (let i = 0; i < targetLines.length; i++) {
+      if (originalLines[pos + i] === targetLines[i]) {
+        matches++;
+      }
+    }
+
+    const score = matches / targetLines.length;
+    const FUZZY_MATCH_THRESHOLD = 0.7; // 70% similarity threshold for fuzzy matching
+    if (score > bestMatch.score && score >= FUZZY_MATCH_THRESHOLD) {
+      bestMatch = { found: true, position: pos, score };
+    }
+  }
+
+  return bestMatch;
+}
+
+function calculateOldCount(changes) {
+  const contextCount = changes.filter((c) => c.type === "context").length;
+  const removeCount = changes.filter((c) => c.type === "remove").length;
+  return contextCount + removeCount;
+}
+
+function calculateNewCount(changes) {
+  const contextCount = changes.filter((c) => c.type === "context").length;
+  const addCount = changes.filter((c) => c.type === "add").length;
+  return contextCount + addCount;
+}
+
+function reconstructDiffPatch(hunks) {
+  let patchContent = "";
+
+  for (const hunk of hunks) {
+    // Add hunk header
+    const oldRange = hunk.oldCount === 1 ? hunk.oldStart : `${hunk.oldStart},${hunk.oldCount}`;
+    const newRange = hunk.newCount === 1 ? hunk.newStart : `${hunk.newStart},${hunk.newCount}`;
+    patchContent += `@@ -${oldRange} +${newRange} @@\n`;
+
+    // Add changes
+    for (const change of hunk.changes) {
+      if (change.type === "context") {
+        patchContent += ` ${change.content}\n`;
+      } else if (change.type === "remove") {
+        patchContent += `-${change.content}\n`;
+      } else if (change.type === "add") {
+        patchContent += `+${change.content}\n`;
+      }
+    }
+  }
+
+  return patchContent;
+}
+
+updateDocumentContent.inputSchema = getUpdateDocumentContentInputJsonSchema();
+updateDocumentContent.outputSchema = getUpdateDocumentContentOutputJsonSchema();
+
+updateDocumentContent.description = "Apply diff patch to update markdown document content";

package/agents/update/index.yaml

@@ -25,17 +25,11 @@ skills:
           })
         }
       ])
-  - ../utils/choose-docs.mjs
-  - ../utils/format-document-structure.mjs
-  - type: team
-    name: batchUpdateDocument
-    skills:
-      - ../update/generate-and-translate-document.yaml
-    iterate_on: selectedDocs
-    concurrency: 3
-  - url: ../utils/check-feedback-refiner.mjs
+  - url: ../utils/choose-docs.mjs
     default_input:
-      stage: document_refine
+      requiredFeedback: false
+  - ../utils/format-document-structure.mjs
+  - ../update/check-update-is-single.mjs
   - url: ../utils/action-success.mjs
     default_input:
       action: "✅ Documents updated successfully"

package/agents/update/update-document-detail.yaml

@@ -0,0 +1,52 @@
+type: ai
+name: updateDocumentDetail
+description: Update and optimize document content based on user feedback using diff patches
+instructions:
+  url: ../../prompts/detail/update-document.md
+input_schema:
+  type: object
+  properties:
+    originalContent:
+      type: string
+      description: Original markdown content to be updated
+    feedback:
+      type: string
+      description: User feedback for content improvements
+    rules:
+      type: string
+      description: User configuration rules
+    locale:
+      type: string
+      description: User language, e.g. zh, en
+    datasources:
+      type: string
+      description: Context for document content
+    glossary:
+      type: string
+      description: Glossary of terms
+    userPreferences:
+      type: string
+      description: User's saved preferences for content and documentation style
+    targetAudience:
+      type: string
+      description: Target audience for the documentation
+    title:
+      type: string
+      description: Document title
+    description:
+      type: string
+      description: Document description
+  required:
+    - originalContent
+    - feedback
+output_schema:
+  type: object
+  properties:
+    updatedContent:
+      type: string
+      description: Final updated markdown content after applying modifications
+    operationSummary:
+      type: string
+      description: Summary of the operations performed on the document content
+skills:
+  - ./document-tools/update-document-content.mjs