@aigne/doc-smith 0.8.12-beta.3 → 0.8.12-beta.4

package/utils/file-utils.mjs

@@ -2,6 +2,10 @@ import { execSync } from "node:child_process";
 import { access, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { glob } from "glob";
+import { isBinaryFile } from "isbinaryfile";
+import { encode } from "gpt-tokenizer";
+import { isGlobPattern } from "./utils.mjs";
+import { INTELLIGENT_SUGGESTION_TOKEN_THRESHOLD } from "./constants/index.mjs";
 
 /**
  * Check if a directory is inside a git repository using git command
@@ -243,3 +247,314 @@ export function resolveToAbsolute(value) {
   if (!value) return undefined;
   return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
 }
+
+/**
+ * Load files from sourcesPath array
+ * Supports file paths, directory paths, and glob patterns
+ * @param {string|string[]} sourcesPath - Single path or array of paths
+ * @param {object} options - Options for file loading
+ * @param {string|string[]} options.includePatterns - Include patterns for directories
+ * @param {string|string[]} options.excludePatterns - Exclude patterns for directories
+ * @param {boolean} options.useDefaultPatterns - Whether to use default patterns (default: true)
+ * @param {string[]} options.defaultIncludePatterns - Default include patterns
+ * @param {string[]} options.defaultExcludePatterns - Default exclude patterns
+ * @returns {Promise<string[]>} Array of absolute file paths
+ */
+export async function loadFilesFromPaths(sourcesPath, options = {}) {
+  const {
+    includePatterns,
+    excludePatterns,
+    useDefaultPatterns = true,
+    defaultIncludePatterns = [],
+    defaultExcludePatterns = [],
+  } = options;
+
+  const paths = Array.isArray(sourcesPath) ? sourcesPath : [sourcesPath];
+  let allFiles = [];
+
+  for (const dir of paths) {
+    try {
+      if (typeof dir !== "string") {
+        console.warn(`Invalid source path: ${dir}`);
+        continue;
+      }
+
+      // First try to access as a file or directory
+      const stats = await stat(dir);
+
+      if (stats.isFile()) {
+        // If it's a file, add it directly without filtering
+        allFiles.push(dir);
+      } else if (stats.isDirectory()) {
+        // If it's a directory, use the existing glob logic
+        // Load .gitignore for this directory
+        const gitignorePatterns = await loadGitignore(dir);
+
+        // Prepare patterns
+        let finalIncludePatterns = null;
+        let finalExcludePatterns = null;
+
+        if (useDefaultPatterns) {
+          // Merge with default patterns
+          const userInclude = includePatterns
+            ? Array.isArray(includePatterns)
+              ? includePatterns
+              : [includePatterns]
+            : [];
+          const userExclude = excludePatterns
+            ? Array.isArray(excludePatterns)
+              ? excludePatterns
+              : [excludePatterns]
+            : [];
+
+          finalIncludePatterns = [...defaultIncludePatterns, ...userInclude];
+          finalExcludePatterns = [...defaultExcludePatterns, ...userExclude];
+        } else {
+          // Use only user patterns
+          if (includePatterns) {
+            finalIncludePatterns = Array.isArray(includePatterns)
+              ? includePatterns
+              : [includePatterns];
+          }
+          if (excludePatterns) {
+            finalExcludePatterns = Array.isArray(excludePatterns)
+              ? excludePatterns
+              : [excludePatterns];
+          }
+        }
+
+        // Get files using glob
+        const filesInDir = await getFilesWithGlob(
+          dir,
+          finalIncludePatterns,
+          finalExcludePatterns,
+          gitignorePatterns,
+        );
+        allFiles = allFiles.concat(filesInDir);
+      }
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        // Path doesn't exist as file or directory, try as glob pattern
+        try {
+          // Check if it looks like a glob pattern
+          const isGlobPatternResult = isGlobPattern(dir);
+
+          if (isGlobPatternResult) {
+            // Use glob to find matching files from current working directory
+            const matchedFiles = await glob(dir, {
+              absolute: true,
+              nodir: true, // Only files, not directories
+              dot: false, // Don't include hidden files
+            });
+
+            if (matchedFiles.length > 0) {
+              allFiles = allFiles.concat(matchedFiles);
+            }
+          }
+        } catch (globErr) {
+          console.warn(`Failed to process glob pattern "${dir}": ${globErr.message}`);
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  return allFiles;
+}
+
+/**
+ * Check if a file is likely a text file by checking if it's binary
+ * @param {string} filePath - File path to check
+ * @returns {Promise<boolean>} True if file appears to be a text file
+ */
+async function isTextFile(filePath) {
+  try {
+    const isBinary = await isBinaryFile(filePath);
+    return !isBinary;
+  } catch (_error) {
+    // If we can't read the file, assume it might be binary to be safe
+    return false;
+  }
+}
+
+/**
+ * Read and parse file contents from an array of file paths
+ * @param {string[]} files - Array of file paths to read
+ * @param {string} baseDir - Base directory for calculating relative paths (defaults to cwd)
+ * @param {object} options - Options for reading files
+ * @param {boolean} options.skipBinaryFiles - Whether to skip binary files (default: true)
+ * @returns {Promise<{sourceId: string, content: string}[]>} Array of file objects with sourceId and content
+ */
+export async function readFileContents(files, baseDir = process.cwd(), options = {}) {
+  const { skipBinaryFiles = true } = options;
+
+  const results = await Promise.all(
+    files.map(async (file) => {
+      // Skip binary files if enabled
+      if (skipBinaryFiles) {
+        const isText = await isTextFile(file);
+        if (!isText) {
+          return null;
+        }
+      }
+
+      try {
+        const content = await readFile(file, "utf8");
+        const relativePath = path.relative(baseDir, file);
+        return {
+          sourceId: relativePath,
+          content,
+        };
+      } catch (error) {
+        // If reading as text fails (e.g., binary file), skip it
+        console.warn(`Failed to read file as text: ${file} - ${error.message}`);
+        return null;
+      }
+    }),
+  );
+
+  // Filter out null results
+  return results.filter((result) => result !== null);
+}
+
+/**
+ * Calculate total lines and tokens from file contents
+ * @param {Array<{content: string}>} sourceFiles - Array of objects containing content property
+ * @returns {{totalTokens: number, totalLines: number}} Object with totalTokens and totalLines
+ */
+export function calculateFileStats(sourceFiles) {
+  let totalTokens = 0;
+  let totalLines = 0;
+
+  for (const source of sourceFiles) {
+    const { content } = source;
+    if (content) {
+      // Count tokens using gpt-tokenizer
+      const tokens = encode(content);
+      totalTokens += tokens.length;
+
+      // Count lines (excluding empty lines)
+      totalLines += content.split("\n").filter((line) => line.trim() !== "").length;
+    }
+  }
+
+  return { totalTokens, totalLines };
+}
+
+/**
+ * Build sources content string based on context size
+ * For large contexts, only include core project files to avoid token limit issues
+ * @param {Array<{sourceId: string, content: string}>} sourceFiles - Array of source file objects
+ * @param {boolean} isLargeContext - Whether the context is large
+ * @returns {string} Concatenated sources content with sourceId comments
+ */
+export function buildSourcesContent(sourceFiles, isLargeContext = false) {
+  // Define core file patterns that represent project structure and key information
+  const coreFilePatterns = [
+    // Configuration files
+    /package\.json$/,
+    /tsconfig\.json$/,
+    /jsconfig\.json$/,
+    /\.env\.example$/,
+    /Cargo\.toml$/,
+    /go\.mod$/,
+    /pom\.xml$/,
+    /build\.gradle$/,
+    /Gemfile$/,
+    /requirements\.txt$/,
+    /Pipfile$/,
+    /composer\.json$/,
+    /pyproject\.toml$/,
+
+    // Documentation
+    /README\.md$/i,
+    /CHANGELOG\.md$/i,
+    /CONTRIBUTING\.md$/i,
+    /\.github\/.*\.md$/i,
+
+    // Entry points and main files
+    /index\.(js|ts|jsx|tsx|py|go|rs|java|rb|php)$/,
+    /main\.(js|ts|jsx|tsx|py|go|rs|java|rb|php)$/,
+    /app\.(js|ts|jsx|tsx|py)$/,
+    /server\.(js|ts|jsx|tsx|py)$/,
+
+    // API definitions
+    /api\/.*\.(js|ts|jsx|tsx|py|go|rs|java|rb|php)$/,
+    /routes\/.*\.(js|ts|jsx|tsx|py|go|rs|java|rb|php)$/,
+    /controllers\/.*\.(js|ts|jsx|tsx|py|go|rs|java|rb|php)$/,
+
+    // Type definitions and schemas
+    /types\.(ts|d\.ts)$/,
+    /schema\.(js|ts|jsx|tsx|py|go|rs|java|rb|php)$/,
+    /.*\.d\.ts$/,
+
+    // Core utilities
+    /utils\/.*\.(js|ts|jsx|tsx|py|go|rs|java|rb|php)$/,
+    /lib\/.*\.(js|ts|jsx|tsx|py|go|rs|java|rb|php)$/,
+    /helpers\/.*\.(js|ts|jsx|tsx|py|go|rs|java|rb|php)$/,
+  ];
+
+  // Function to check if a file is a core file
+  const isCoreFile = (filePath) => {
+    return coreFilePatterns.some((pattern) => pattern.test(filePath));
+  };
+
+  // Build sources string
+  let allSources = "";
+
+  if (isLargeContext) {
+    // Only include core files for large contexts
+    const coreFiles = sourceFiles.filter((source) => isCoreFile(source.sourceId));
+
+    // Determine which files to use and set appropriate message
+    const filesToInclude = coreFiles.length > 0 ? coreFiles : sourceFiles;
+    const noteMessage =
+      coreFiles.length > 0
+        ? "// Note: Context is large, showing only core project files.\n"
+        : "// Note: Context is large, showing a sample of files.\n";
+
+    allSources += noteMessage;
+    let accumulatedTokens = 0;
+
+    for (const source of filesToInclude) {
+      const fileContent = `// sourceId: ${source.sourceId}\n${source.content}\n`;
+      const fileTokens = encode(fileContent);
+
+      // Check if adding this file would exceed the token limit
+      if (accumulatedTokens + fileTokens.length > INTELLIGENT_SUGGESTION_TOKEN_THRESHOLD) {
+        break;
+      }
+
+      allSources += fileContent;
+      accumulatedTokens += fileTokens.length;
+    }
+  } else {
+    // Include all files for normal contexts
+    for (const source of sourceFiles) {
+      allSources += `// sourceId: ${source.sourceId}\n${source.content}\n`;
+    }
+  }
+
+  return allSources;
+}
+
+/**
+ * Get doc-smith configuration file path
+ * @param {string} workDir - Working directory (defaults to current directory)
+ * @returns {string} Absolute path to config.yaml
+ */
+export function getConfigFilePath(workDir) {
+  const cwd = workDir || process.cwd();
+  return path.join(cwd, ".aigne", "doc-smith", "config.yaml");
+}
+
+/**
+ * Get doc-smith structure plan file path
+ * @param {string} workDir - Working directory (defaults to current directory)
+ * @returns {string} Absolute path to structure-plan.json
+ */
+export function getStructurePlanPath(workDir) {
+  const cwd = workDir || process.cwd();
+  return path.join(cwd, ".aigne", "doc-smith", "output", "structure-plan.json");
+}

package/utils/utils.mjs

@@ -873,6 +873,81 @@ export async function getProjectInfo() {
   };
 }
 
+/**
+ * Process document purpose configuration and generate purpose rules
+ * @param {Array<string>} documentPurpose - Array of document purpose keys
+ * @returns {Object} Object containing purposes string and rules content
+ */
+export function processDocumentPurpose(documentPurpose) {
+  if (!documentPurpose || !Array.isArray(documentPurpose)) {
+    return { purposes: "" };
+  }
+
+  const purposeRules = documentPurpose
+    .map((key) => {
+      const style = DOCUMENT_STYLES[key];
+      if (!style) return null;
+      return `Document Purpose - ${style.name}:\n${style.description}\n${style.content}`;
+    })
+    .filter(Boolean);
+
+  if (purposeRules.length === 0) {
+    return { purposes: "" };
+  }
+
+  const purposes = purposeRules.join("\n\n");
+  return {
+    purposes,
+  };
+}
+
+/**
+ * Process target audience configuration and generate audience rules and names
+ * @param {Array<string>} targetAudienceTypes - Array of target audience type keys
+ * @param {string} existingTargetAudience - Existing target audience content
+ * @returns {Object} Object containing audiences string, targetAudience string, and rules content
+ */
+export function processTargetAudience(targetAudienceTypes, existingTargetAudience = "") {
+  if (!targetAudienceTypes || !Array.isArray(targetAudienceTypes)) {
+    return { audiences: "", targetAudience: existingTargetAudience || "" };
+  }
+
+  // Get structured content for rules
+  const audienceRules = targetAudienceTypes
+    .map((key) => {
+      const audience = TARGET_AUDIENCES[key];
+      if (!audience) return null;
+      return `Target Audience - ${audience.name}:\n${audience.description}\n${audience.content}`;
+    })
+    .filter(Boolean);
+
+  let audiences = "";
+  if (audienceRules.length > 0) {
+    audiences = audienceRules.join("\n\n");
+  }
+
+  // Get names for targetAudience field
+  const audienceNames = targetAudienceTypes
+    .map((key) => TARGET_AUDIENCES[key]?.name)
+    .filter(Boolean)
+    .join(", ");
+
+  let targetAudience = existingTargetAudience || "";
+  if (audienceNames) {
+    const existingTargetAudienceTrimmed = existingTargetAudience?.trim();
+    if (existingTargetAudienceTrimmed) {
+      targetAudience = `${existingTargetAudienceTrimmed}\n\n${audienceNames}`;
+    } else {
+      targetAudience = audienceNames;
+    }
+  }
+
+  return {
+    audiences,
+    targetAudience,
+  };
+}
+
 /**
  * Process configuration fields - convert keys to actual content
  * @param {Object} config - Parsed configuration
@@ -924,59 +999,23 @@ export function processConfigFields(config) {
   }
 
   // Process document purpose (array)
-  if (config.documentPurpose && Array.isArray(config.documentPurpose)) {
-    const purposeRules = config.documentPurpose
-      .map((key) => {
-        const style = DOCUMENT_STYLES[key];
-        if (!style) return null;
-        return `Document Purpose - ${style.name}:\n${style.description}\n${style.content}`;
-      })
-      .filter(Boolean);
-
-    if (purposeRules.length > 0) {
-      const purposes = purposeRules.join("\n\n");
-      allRulesContent.push(purposes);
-
-      processed.purposes = purposes;
-    }
+  const documentPurposeResult = processDocumentPurpose(config.documentPurpose);
+  if (documentPurposeResult.purposes) {
+    allRulesContent.push(documentPurposeResult.purposes);
+    processed.purposes = documentPurposeResult.purposes;
   }
 
   // Process target audience types (array)
-  let audienceNames = "";
-  if (config.targetAudienceTypes && Array.isArray(config.targetAudienceTypes)) {
-    // Get structured content for rules
-    const audienceRules = config.targetAudienceTypes
-      .map((key) => {
-        const audience = TARGET_AUDIENCES[key];
-        if (!audience) return null;
-        return `Target Audience - ${audience.name}:\n${audience.description}\n${audience.content}`;
-      })
-      .filter(Boolean);
-
-    if (audienceRules.length > 0) {
-      const audiences = audienceRules.join("\n\n");
-      allRulesContent.push(audiences);
-
-      processed.audiences = audiences;
-    }
-
-    // Get names for targetAudience field
-    audienceNames = config.targetAudienceTypes
-      .map((key) => TARGET_AUDIENCES[key]?.name)
-      .filter(Boolean)
-      .join(", ");
-
-    if (audienceNames) {
-      // Check if original targetAudience field has content
-      const existingTargetAudience = config.targetAudience?.trim();
-      const newAudienceNames = audienceNames;
-
-      if (existingTargetAudience) {
-        processed.targetAudience = `${existingTargetAudience}\n\n${newAudienceNames}`;
-      } else {
-        processed.targetAudience = newAudienceNames;
-      }
-    }
+  const targetAudienceResult = processTargetAudience(
+    config.targetAudienceTypes,
+    config.targetAudience,
+  );
+  if (targetAudienceResult.audiences) {
+    allRulesContent.push(targetAudienceResult.audiences);
+    processed.audiences = targetAudienceResult.audiences;
+  }
+  if (targetAudienceResult.targetAudience) {
+    processed.targetAudience = targetAudienceResult.targetAudience;
   }
 
   // Process reader knowledge level (single value)

package/docs/advanced-how-it-works.ja.md

@@ -1,101 +0,0 @@
-# 仕組み
-
-AIGNE DocSmithは、マルチagentシステムで動作します。単一のモノリシックなプロセスではなく、専門のAI agentのパイプラインを編成し、各agentが特定のタスクを担当します。このアプローチにより、ソースコードを完全なドキュメントに変換するための構造化されたモジュラーなプロセスが可能になります。
-
-このツールは、AIアプリケーションを開発・展開するためのプラットフォームを提供する、より大きなAIGNEエコシステムの不可欠な部分です。
-
-![AIGNEエコシステムのアーキテクチャ](https://docsmith.aigne.io/image-bin/uploads/def424c20bbdb3c77483894fe0e22819.png)
-
-## ドキュメント生成パイプライン
-
-DocSmithの中核は、ソースコードをいくつかの異なるステージを通して処理するパイプラインです。各ステージは1つ以上の専用agentによって管理されます。通常、`aigne doc generate`コマンドによって開始される主要なワークフローは、次のように視覚化できます。
-
-```d2
-direction: down
-
-Input: {
-  label: "ソースコードと設定"
-  shape: rectangle
-}
-
-Pipeline: {
-  label: "コア生成パイプライン"
-  shape: rectangle
-  grid-columns: 1
-  grid-gap: 40
-
-  Structure-Planning: {
-    label: "1. 構造計画"
-    shape: rectangle
-  }
-
-  Content-Generation: {
-    label: "2. コンテンツ生成"
-    shape: rectangle
-  }
-
-  Saving: {
-    label: "3. ドキュメント保存"
-    shape: rectangle
-  }
-}
-
-User-Feedback: {
-  label: "ユーザーフィードバックループ\n(--feedbackフラグ経由)"
-  shape: rectangle
-}
-
-Optional-Steps: {
-  label: "オプションの生成後ステップ"
-  shape: rectangle
-  grid-columns: 2
-  grid-gap: 40
-  
-  Translation: {
-    label: "翻訳\n(aigne doc translate)"
-    shape: rectangle
-  }
-
-  Publishing: {
-    label: "公開\n(aigne doc publish)"
-    shape: rectangle
-  }
-}
-
-Input -> Pipeline.Structure-Planning
-Pipeline.Structure-Planning -> Pipeline.Content-Generation
-Pipeline.Content-Generation -> Pipeline.Saving
-Pipeline.Saving -> Optional-Steps
-
-User-Feedback -> Pipeline.Structure-Planning: "構造の改良"
-User-Feedback -> Pipeline.Content-Generation: "コンテンツの再生成"
-```
-
-1.  **入力分析**: このプロセスは、agentがソースコードとプロジェクト設定（`aigne.yaml`）を読み込むことから始まります。
-
-2.  **構造計画**: あるagentがコードベースを分析し、論理的なドキュメント構造を提案します。プロジェクトの構成と指定されたルールに基づいてアウトラインを作成します。
-
-3.  **コンテンツ生成**: 構造が決定されると、コンテンツ生成agentがドキュメントプランの各セクションに詳細なテキスト、コード例、説明を埋め込んでいきます。
-
-4.  **改良と更新**: `aigne doc update`または`aigne doc generate --feedback`を介して入力が提供されると、特定のagentがアクティブになり、個々のドキュメントを更新したり、全体の構造を調整したりします。
-
-5.  **翻訳と公開**: 主要なコンテンツが生成された後、オプションのagentが多言語翻訳や最終的なドキュメントをウェブプラットフォームに公開するなどのタスクを処理します。
-
-## 主要なAI Agent
-
-DocSmithの機能は、プロジェクトの設定で定義されたagentのコレクションによって提供されます。各agentには特定の役割があります。以下の表は、主要なagentとその機能の一部をリストアップしたものです。
-
-| 機能的役割 | 主要なAgentファイル | 説明 |
-| :--- | :--- | :--- |
-| **構造計画** | `generate/generate-structure.yaml` | ソースコードを分析し、最初のドキュメントアウトラインを提案します。 |
-| **構造の改良** | `generate/refine-document-structure.yaml` | ユーザーのフィードバックに基づいてドキュメントの構造を修正します。 |
-| **コンテンツ生成** | `update/batch-generate-document.yaml`, `update/generate-document.yaml` | ドキュメント構造の各セクションに詳細なコンテンツを埋め込みます。 |
-| **翻訳** | `translate/translate-document.yaml`, `translate/translate-multilingual.yaml` | 生成されたドキュメントを複数のターゲット言語に翻訳します。 |
-| **公開** | `publish/publish-docs.mjs` | ドキュメントをDiscuss Kitインスタンスに公開するプロセスを管理します。 |
-| **データI/O** | `utils/load-sources.mjs`, `utils/save-docs.mjs` | ソースファイルの読み込みと、最終的なマークダウンドキュメントのディスクへの書き込みを担当します。 |
-
-このagentベースのアーキテクチャにより、ドキュメント化プロセスの各ステップを専門のツールで処理できるため、構造化され、保守可能なワークフローが保証されます。
-
----
-
-DocSmithが出力の正確性と形式を保証するために講じている対策を理解するには、[品質保証](./advanced-quality-assurance.md)のセクションに進んでください。

package/docs/advanced-how-it-works.md

@@ -1,101 +0,0 @@
-# How It Works
-
-AIGNE DocSmith operates on a multi-agent system. Instead of a single monolithic process, it orchestrates a pipeline of specialized AI agents, where each agent is responsible for a specific task. This approach allows for a structured and modular process that transforms source code into complete documentation.
-
-The tool is an integral part of the larger AIGNE ecosystem, which provides a platform for developing and deploying AI applications.
-
-![AIGNE Ecosystem Architecture](https://docsmith.aigne.io/image-bin/uploads/def424c20bbdb3c77483894fe0e22819.png)
-
-## The Documentation Generation Pipeline
-
-The core of DocSmith is a pipeline that processes your source code through several distinct stages. Each stage is managed by one or more dedicated agents. The primary workflow, typically initiated by the `aigne doc generate` command, can be visualized as follows:
-
-```d2
-direction: down
-
-Input: {
-  label: "Source Code & Config"
-  shape: rectangle
-}
-
-Pipeline: {
-  label: "Core Generation Pipeline"
-  shape: rectangle
-  grid-columns: 1
-  grid-gap: 40
-
-  Structure-Planning: {
-    label: "1. Structure Planning"
-    shape: rectangle
-  }
-
-  Content-Generation: {
-    label: "2. Content Generation"
-    shape: rectangle
-  }
-
-  Saving: {
-    label: "3. Save Documents"
-    shape: rectangle
-  }
-}
-
-User-Feedback: {
-  label: "User Feedback Loop\n(via --feedback flag)"
-  shape: rectangle
-}
-
-Optional-Steps: {
-  label: "Optional Post-Generation Steps"
-  shape: rectangle
-  grid-columns: 2
-  grid-gap: 40
-  
-  Translation: {
-    label: "Translate\n(aigne doc translate)"
-    shape: rectangle
-  }
-
-  Publishing: {
-    label: "Publish\n(aigne doc publish)"
-    shape: rectangle
-  }
-}
-
-Input -> Pipeline.Structure-Planning
-Pipeline.Structure-Planning -> Pipeline.Content-Generation
-Pipeline.Content-Generation -> Pipeline.Saving
-Pipeline.Saving -> Optional-Steps
-
-User-Feedback -> Pipeline.Structure-Planning: "Refine Structure"
-User-Feedback -> Pipeline.Content-Generation: "Regenerate Content"
-```
-
-1.  **Input Analysis**: The process begins when agents load your source code and project configuration (`aigne.yaml`).
-
-2.  **Structure Planning**: An agent analyzes the codebase to propose a logical documentation structure. It creates an outline based on the project's composition and any specified rules.
-
-3.  **Content Generation**: With the structure in place, content generation agents populate each section of the document plan with detailed text, code examples, and explanations.
-
-4.  **Refinement and Updates**: When you provide input via `aigne doc update` or `aigne doc generate --feedback`, specific agents are activated to update individual documents or adjust the overall structure.
-
-5.  **Translation and Publishing**: After the primary content is generated, optional agents handle tasks like multi-language translation and publishing the final documentation to a web platform.
-
-## Key AI Agents
-
-DocSmith's functionality is provided by a collection of agents defined in the project's configuration. Each agent has a specific role. The table below lists some of the key agents and their functions.
-
-| Functional Role | Key Agent Files | Description |
-| :--- | :--- | :--- |
-| **Structure Planning** | `generate/generate-structure.yaml` | Analyzes source code to propose the initial document outline. |
-| **Structure Refinement** | `generate/refine-document-structure.yaml` | Modifies the documentation structure based on user feedback. |
-| **Content Generation** | `update/batch-generate-document.yaml`, `update/generate-document.yaml` | Populates the documentation structure with detailed content for each section. |
-| **Translation** | `translate/translate-document.yaml`, `translate/translate-multilingual.yaml` | Translates generated documentation into multiple target languages. |
-| **Publishing** | `publish/publish-docs.mjs` | Manages the process of publishing documents to Discuss Kit instances. |
-| **Data I/O** | `utils/load-sources.mjs`, `utils/save-docs.mjs` | Responsible for reading source files and writing the final markdown documents to disk. |
-
-This agent-based architecture allows each step of the documentation process to be handled by a specialized tool, ensuring a structured and maintainable workflow.
-
----
-
-To understand the measures DocSmith takes to ensure the accuracy and format of the output, proceed to the [Quality Assurance](./advanced-quality-assurance.md) section.