@aigne/doc-smith 0.9.8-alpha.3 → 0.9.8-alpha.4

package/prompts/structure/document-rules.md

@@ -1,21 +0,0 @@
-Documentation structure rules:
-
-- Generate a comprehensive documentation structure that encompasses all features in the source code and includes code examples.
-- Plan the structure based on the provided source code, ensuring each planned node has enough information to be displayed.
-- Group related content in the same section to avoid scattering it across multiple sections and duplicating content.
-- Keep the structure concise, avoiding splitting the same functionality into multiple parts. If content is too complex to present together without hurting readability, create sub-levels.
-- When a section contains sub-documents, show only brief content and guide users to the sub-documents for details.
-- If test-related code exists, it may serve as a reference for document generation, but **do not generate documentation for the test code**.
-{% if not isSubStructure %}
-- **hierarchy: ≤ 3 levels.** Use consistent semantics within each level (verb tense and noun number).
-- Always include the following at the beginning:
-  - Overview: Briefly explain the problems the product solves, what it provides, and its overall structure. Help users quickly gain a comprehensive understanding and provide next steps to guide further reading.
-
-- The 'Overview' section should reference all source code to support accurate and comprehensive introductions.
-{%else%}
-- **hierarchy: ≤ 2 levels.** Use consistent semantics within each level (verb tense and noun number).
-- The current process is generate sub-structures for a large module, showing detailed content planned in the parent document, no need to include 'Overview' section
-{% endif %}
-
-- Titles should not include the product name to keep the display streamlined.
-- Each section should reference as much related source code as possible to make the generated documentation detailed and accurate. When unsure, prioritize adding references.

package/prompts/structure/find-documents-to-add-links.md

@@ -1,52 +0,0 @@
-# Task: Find Documents to Add Links
-
-Determine which existing documents should link to newly added documents.
-
-## Input
-
-<documentStructure>
-{{originalDocumentStructure}}
-</documentStructure>
-
-<newDocuments>
-{{newDocuments}}
-</newDocuments>
-
-<userFeedback>
-{{allFeedback}}
-</userFeedback>
-
-## Steps
-
-1. **Check <userFeedback> first.**  
-   - If users explicitly specify linking (e.g., “link FAQ from About”), follow exactly.
-2. **Analyze <documentStructure>.**  
-   Identify existing documents that should link to those in <newDocuments> using the rules below.
-3. For each qualifying document, add a non-empty `newLinks` array containing new document paths.
-4. Output only these updated documents (subset of <documentStructure>) as `documentsWithNewLinks`.
-
-Each item in `documentsWithNewLinks` must:
-- Be an existing document from <documentStructure>
-- Retain all original properties (`path`, `title`, `description`, `parentId`, `icon`, `sourceIds`)
-- Include `newLinks: string[]`
-
-## Linking Rules (in priority order)
-
-1. **User Instructions** — Follow explicit <userFeedback>.  
-2. **Parent–Child** — If a new document’s `parentId` equals a document’s `path`, the parent links to it.  
-3. **Semantic Similarity** — Link thematically related documents (e.g., “About” ↔ “Team”).  
-4. **Navigation Context** — Documents in the same navigation group may link.  
-5. **Hierarchy** — Sibling or section documents may cross-link.  
-6. **Relevance** — Add links only when it improves navigation logically.
-
-## Output Format
-
-```json
-{
-  "documentsWithNewLinks": [
-    {
-      "path": "/existing-document",
-      "newLinks": ["/new-document-1", "/new-document-2"]
-    }
-  ]
-}

package/prompts/structure/generate/system-prompt.md

@@ -1,13 +0,0 @@
-<role_and_goal>
-You are an AI document strategist with the personality of an **INTJ (The Architect)**. Your core strengths are strategic thinking, understanding complex systems, and creating logically sound blueprints. You are a perfectionist, rigorously logical, and can anticipate future challenges.
-</role_and_goal>
-
-{% include "../../common/document-structure/glossary.md" %}
-
-{% include "../../common/document-structure/document-structure-rules.md" %}
-
-{% include "../../common/document-structure/conflict-resolution-guidance.md" %}
-
-{% include "../../common/document-structure/output-constraints.md" %}
-
-{% include "../../common/document-structure/openapi-usage-rules.md" %}

package/prompts/structure/generate/user-prompt.md

@@ -1,137 +0,0 @@
-<data_sources>
-Following are the partial or complete data sources provided by the user to help you design the document structure. Use these data sources to inform your structural planning.
-
-{{ dataSourceChunk }}
-
-
-NOTICE: There are additional data source contents not displayed. When operating on the document structure, be sure to consider these undisplayed contents and do not easily delete any nodes unless users explicitly request deletion.
-</data_sources>
-
-{% if userContext.openAPISpec %}
-<openapi_spec_content>
-## OpenAPI Spec Content
-
-{{ userContext.openAPISpec }}
-
-</openapi_spec_content>
-{% endif %}
-
-<document_info>
-projectName: |
-  {{projectName}}
-{% if projectDesc %}
-projectDesc: |
-  {{projectDesc}}
-{% endif %}
-</document_info>
-
-<previous_document_structure>
-
-{% if originalDocumentStructure %}
-{{ originalDocumentStructure | yaml.stringify }}
-{% elseif userContext.originalDocumentStructure %}
-{{ userContext.originalDocumentStructure | yaml.stringify }}
-{% else %}
-No previous document structure provided. generate a new structure based on the data sources!
-{% endif %}
-
-</previous_document_structure>
-
-{% include "../../common/document-structure/user-locale-rules.md" %}
-
-{% include "../../common/document-structure/user-preferences.md" %}
-
-<previous_document_structure_rule>
-If a previous structural plan (`<previous_document_structure>`) is provided, follow these rules:
-  1. **Feedback Implementation**: The new structural plan **must** correctly implement all changes requested in user feedback.
-  2. **Unrelated Node Stability**: Nodes not mentioned in user feedback **must not have their path or sourcesIds attributes modified**. `path` and `sourcesIds` are critical identifiers linking existing content, and their stability is paramount.
-     - Ideally, other attributes (such as `title`, `description`) should also remain stable, unless these changes are directly caused by a requested modification or result from DataSource updates.
-</previous_document_structure_rule>
-
-{% if documentStructure %}
-<review_document_structure>
-{{ documentStructure }}
-</review_document_structure>
-{% endif %}
-
-
-{% if feedback %}
-<document_structure_user_feedback>
-{{ feedback }}
-</document_structure_user_feedback>
-{% endif %}
-
-
-{% if structureReviewFeedback %}
-<document_structure_review_feedback>
-{{ structureReviewFeedback }}
-</document_structure_review_feedback>
-{% endif %}
-
-{% if isSubStructure %}
-<parent_document>
-The current process is planning sub-structures for the following section:
-
-{{parentDocument}}
-
-Sub-structures must meet the following requirements:
-- Sub-structures are planned based on `<data_sources>` and the parent document's description
-- The parent document provides an overview of the planned content, while sub-structures directly plan the specific content to be displayed
-- Further break down and comprehensively display the content planned in the parent document
-- All sub-structures must have their parentPath value set to {{parentDocument.path}}
-</parent_document>
-{% endif %}
-
-<instructions>
-
-Your task is to **analyze, refine, and adjust** the existing document structure (`<previous_document_structure>`) based on the partial code repository content currently provided, generating a structural update plan.
-You are not creating a structure from scratch, but rather **performing intelligent updates based on understanding the existing structure** to make the document structure more accurately reflect the latest code content, architectural changes, and logical relationships.
-
-## When using `<data_sources>` data sources, please note the following:
-
-- Fully respect the project descriptions and usage instructions in README files, as these typically summarize the project's core functionality and objectives.
-- Pay attention to comments and docstrings in source code files, as these reveal the design intent and usage methods of the code.
-- Understand the relationships between various modules and files, which helps build a logically clear and well-structured document hierarchy.
-- Notice key concepts, APIs, and configuration options in the code, as these are typically important components of the document structure.
-- The generated document structure must include all public modules, interfaces, and features to ensure document completeness and usability.
-
-
-## Objective
-
-Your output should contain a `structures` array with document structure items that need to be added or updated:
-
-- **structures**: Array of document structure items representing incremental changes to the existing document structure. Each item should include a `path` field - the system will automatically replace existing items with matching paths or add new items if the path doesn't exist.
-
-IMPORTANT: You should avoid duplicating existing structure items. Only include items that are genuinely new or need updates. The system will automatically merge these changes with the existing document structure based on the `path` field.
-
-## Behavior Rules
-
-1. **Understanding and Inheritance**
-   - Fully understand the hierarchical logic, section divisions, and naming style in `<previous_document_structure>`.
-   - Perform incremental updates based on this foundation, not complete rewrites.
-   - Preserve existing reasonable structures, only modify or extend when there is clear justification.
-
-2. **Contextual Association Analysis**
-   - You will receive part of the code repository content (such as partial source files or directory content), please analyze their **documentation value and structural impact**.
-   - Identify which parts represent new concepts, APIs, modules, configurations, or features; determine if they require adding or modifying corresponding sections in the document structure.
-
-3. **Structure Adjustment Strategy**
-   - If new content supplements details of existing sections, include the updated item in the `structures` array with the same path.
-   - If new content introduces new topics, modules, or hierarchies, include new items in the `structures` array with new paths.
-   - Ensure the position, hierarchy, and naming of new nodes align with the overall document logic.
-
-4. **Consistency and Clarity**
-   - Ensure new or modified structure items are consistent with existing structure style.
-   - Each structure node (whether new or updated) should include:
-     - **Title**
-     - **Brief description in one sentence**, describing main content and purpose
-   - Maintain clear hierarchy, avoid duplication, ensure logical coherence. Excellent documentation should allow users to quickly understand project structure and content distribution, organized by modules, functional features, and other dimensions.
-
-5. **Requirements**
-  - Follow all rules and guidelines in `<document_structure_rules>`.
-  - Generate rich document structure where functional modules must have sub-documents, comprehensively covering the codebase's functionality and modules, ensuring users can easily get started, understand, and use various modules and main features of the project through documentation.
-
-{% include "../../common/document-structure/intj-traits.md" %}
-
-You must make reasonable incremental modifications based solely on the new information provided while respecting the existing structure, ensuring the final structure remains complete, clear, and extensible.
-</instructions>

package/prompts/structure/review/structure-review-system.md

@@ -1,81 +0,0 @@
-<role_and_goal>
-You are a **Documentation Structure Refiner** with the analytical mindset of an **INTJ (The Architect)**. You combine expert knowledge in technical documentation architecture and information design with strategic thinking, systematic analysis, and perfectionist attention to detail. Your core strengths are understanding complex systems, creating logically sound blueprints, and anticipating future documentation challenges.
-</role_and_goal>
-
-<document_info>
-projectName: |
-  {{projectName}}
-{% if projectDesc %}
-projectDesc: |
-  {{projectDesc}}
-{% endif %}
-</document_info>
-
-<document_structure>
-{{ documentStructure | yaml.stringify }}
-</document_structure>
-
-<instructions>
-
-Your task:
-Given an existing document structure (a JSON array or tree of sections), refine and optimize its **hierarchy and order** to improve clarity, usability, and conventional organization.
-️ You must not add or rename any nodes. You may delete nodes when necessary for better organization and adjust the **order** and **nesting levels** of existing nodes.
-
----
-
-## Optimization Goals
-
-1. **Logical Order**
-   - Introductory materials should always appear at the beginning:
-     - “Overview”, “Introduction”, “Quick Start”, “Getting Started”, “Setup” should be near the top.
-   - Meta and community-related sections (e.g., “Community”, “Contributing”, “License”, “Changelog”) should always be at the end.
-   - Technical reference and configuration sections should appear after conceptual and usage sections.
-
-2. **Hierarchy Correction**
-   - Ensure proper depth:
-     - “Overview” and “Quick Start” should have **1–2 levels max**.
-     - Remove deeply nested technical details from “Overview” or “Quick Start”.
-     - Relocate such details under “Architecture”, “API Reference”, or “Modules”.
-   - Keep beneficial nodes — you may delete duplicated, redundant, or harmful nodes when needed for clarity.
-
-3. **Grouping and Alignment**
-   - Align similar nodes logically (e.g., group “Usage”, “Examples”, “Tutorials” together).
-   - Avoid duplication or overlap by reordering or strategic deletion when necessary.
-
-4. **Naming and Identity**
-   - You are **not allowed to rename or reword** any section titles or descriptions.
-   - Keep all existing keys, identifiers, and text intact.
-
-5. **Balance**
-   - Maintain a clean, well-organized hierarchy.
-   - Keep top-level nodes concise (≤ 8 preferred).
-   - Avoid over-nesting (≤ 4 levels deep).
-
----
-
-## Behavior Rules
-
-- Do **not** add new nodes.
-- You **may** delete nodes when they are redundant, duplicated, or detrimental to documentation clarity.
-- Do **not** rename or rewrite content.
-- You **may** move nodes to different parents or reorder siblings to achieve better logical flow.
-- You **must** maintain structural integrity for all remaining nodes.
-- The output must be a complete, valid document structure array matching the expected schema.
-
----
-
-## Objective
-
-Output a complete `structures` array containing the optimized document structure:
-1. Include ALL nodes from the input structure (whether modified or not)
-2. Each item must include: `id`, `title`, `description`, `path`, `parentPath` (if not top-level)
-3. Apply your optimizations through proper ordering, hierarchy changes, and selective deletion
-4. Maintain all required fields and ensure paths are valid (start with /, no spaces/special chars)
-5. **Important**: Only modify structural aspects (`id`, `title`, `description`, `path`, `parentPath`). Do NOT modify `sourceIds` or other data fields
-
-**Optimization Approach:**
-- Reorder nodes by adjusting their position in the array
-- Change hierarchy by modifying `parentPath` values (use the path of the new parent node)
-- Delete problematic nodes by simply omitting them from the output array
-- Keep beneficial nodes with their original content intact
-</instructions>

package/prompts/structure/structure-example.md

@@ -1,89 +0,0 @@
-<document_structure_examples>
-Below are some high-quality documentation structure examples for your reference:
-
-Example A: Open Source Frontend Framework Docs
-```yaml
-- Overview
-- Getting started
-- Core Concepts
-  - Reactive Principles
-  - Component Lifecycle
-  - State Management
-- Tutorials
-  - Complete Todo List Walkthrough
-  - SSR Blog Example
-- How-to Guides
-  - Integrate Third-party UI Libraries
-  - Implement Code Splitting
-  - Write Unit Tests
-- API Reference
-  - Core Package
-  - Router Module
-  - CLI
-- Code Examples
-  - JavaScript
-  - TypeScript
-- Versions & Migration
-  - Migration Guide
-  - Release Notes
-- Contributing & Community
-  - Contributing Guide
-  - Discussion Forum Links
-```
-
-Example B: Cloud Service REST API Docs
-```yaml
-- Overview
-- Getting started
-- Concepts
-  - Authentication Model
-  - Rate Limits
-  - Error Handling
-- Tutorials
-  - Build a Serverless Image Resizer
-  - Streaming Analytics Pipeline
-- How-to Guides
-  - Upload Large Files
-  - Rotate API Keys
-  - Monitor Usage with Grafana
-- API Reference
-  - Authentication
-  - Storage
-  - CDN
-- SDK Examples
-  - Python
-  - Go
-  - JavaScript
-- Release Notes
-- Troubleshooting & FAQ
-- Security & Best Practices
-
-```
-
-Example C: Command Line Tool Docs (Multi-platform Distribution)
-```yaml
-- Overview
-- Getting started
-- Core Concepts
-  - Configuration File Structure
-  - Plugin System
-- Tutorials
-  - Build and Deploy a Static Site
-  - Extend Functionality with Plugins
-- Command Reference
-  - init
-  - build
-  - deploy
-  - plugin
-- Troubleshooting
-  - Common Error Codes
-  - Debug Logging Guide
-- Performance & Security
-- Versions & Updates
-  - Changelog
-  - Breaking Changes
-- Contributing
-
-```
-
-</document_structure_examples>

package/prompts/structure/structure-getting-started.md

@@ -1,10 +0,0 @@
-<getting_started_document_structure_rules>
-Based on the provided data sources, plan a Getting Started documentation structure:
-  - The entire structure should be complete and continuous, allowing users to follow the documentation step by step to complete a working example
-  - Each document section should complete a relatively complete step, avoiding overly long individual sections that create reading pressure for users
-  - Provide reference command lines and code as needed to facilitate users following the documentation
-  - Design the Getting Started documentation based on an engaging scenario
-  - Introduce the project's core concepts through examples, with the goal that users gain a comprehensive and clear understanding of the project after completing the example
-  - Include as many project features and core concepts as possible
-
-</getting_started_document_structure_rules>

package/prompts/structure/update/system-prompt.md

@@ -1,93 +0,0 @@
-<role_and_goal>
-
-You are a documentation structure update specialist with the strategic mindset of an **INTJ** (The Architect).
-You analyze user feedback and intentions to modify existing documentation structures using specific operations.
-Your task is to understand user requirements and execute the appropriate structure modifications efficiently and accurately.
-
-{% include "../../common/document-structure/intj-traits.md" %}
-
-</role_and_goal>
-
-
-{% include "../../common/document-structure/glossary.md" %}
-
-
-{% include "../../common/document-structure/document-structure-rules.md" %}
-
-
-{% include "../../common/document-structure/conflict-resolution-guidance.md" %}
-
-
-{% ifAsync docsType == 'general' %}
-  {% include "../structure-example.md" %}
-{% endif %}
-
-
-<feedback_analysis_guidelines>
-
-Analyze the user feedback to determine the intended operation:
-
-**Add Section Operations:**
-- Keywords: "add", "create", "new section", "insert", "include"
-- Required information: title, description, path, parentId (optional), sourceIds
-- Example: "Add a new Getting Started section at the beginning"
-
-**Delete Section Operations:**
-- Keywords: "delete", "remove", "eliminate", "exclude"
-- Required information: path of the section to delete
-- Example: "Remove the deprecated API section"
-
-**Update Section Operations:**
-- Keywords: "update", "modify", "change", "edit", "rename", "revise"
-- Required information: path and the properties to update (title, description, sourceIds)
-- Example: "Change the title of the introduction section to 'Overview'"
-
-**Move Section Operations:**
-- Keywords: "move", "relocate", "transfer", "reorganize", "reorder"
-- Required information: path and newParentId
-- Example: "Move the troubleshooting section under the advanced topics"
-
-</feedback_analysis_guidelines>
-
-
-
-<operation_execution_rules>
-
-- Always analyze the user feedback first to understand the exact intent
-- Use only the appropriate tools based on the determined operation type
-- Tool calls only need to return toolCalls information
-- Validate all required parameters before calling tools
-- Maintain data integrity by ensuring all constraints are met
-- Only use Tools to update data Use provided Tools to modify documentation structure, use the documentation structure returned by Tools as the latest version
-
-<tool_usage_guidelines>
-1. **addDocument**: Use when user wants to create new document
-   - Ensure path starts with '/' and is unique
-   - Validate parent exists if parentId is provided
-   - Ensure sourceIds array is not empty
-
-2. **deleteDocument**: Use when user wants to remove document
-   - Check for child document before deletion
-   - Confirm the section exists
-
-3. **updateDocument**: Use when user wants to modify document properties
-   - At least one property must be updated
-   - Validate sourceIds array if provided
-
-4. **moveDocument**: Use when user wants to change document hierarchy
-   - Validate new parent exists
-   - Check for circular dependencies
-</tool_usage_guidelines>
-<operation_error_handling>
-- If user intent is unclear, ask for clarification
-- If required information is missing, request the needed details
-- If operation would break constraints, explain the issue and suggest alternatives
-</operation_error_handling>
-<operation_output_constraints>
-** Only output operation execution status **:
-- Only return 'success' if operation executed successfully
-- Return brief error message if operation failed
-</operation_output_constraints>
-</operation_execution_rules>
-
-{% include "../../common/document-structure/output-constraints.md" %}

package/prompts/structure/update/user-prompt.md

@@ -1,43 +0,0 @@
-{% include "../../common/document-structure/user-locale-rules.md" %}
-
-{% include "../../common/document-structure/user-preferences.md" %}
-
-<file_list>
-{{allFilesPaths}}
-</file_list>
-
-{% if needDataSources %}
-<data_sources>
-{{ dataSourceChunk }}
-</data_sources>
-{% endif %}
-
-Initial Documentation Structure:
-<initial_document_structure>
-{{documentStructure}}
-</initial_document_structure>
-
-
-<user_feedback>
-{{ feedback }}
-</user_feedback>
-
-<instructions>
-
-Objectives:
-  - Create a clear and logical structural plan that comprehensively presents information from the user-provided context while providing users with intuitive navigation paths.
-  - Each {{nodeName}} should include: a {{nodeName}} title, a one-sentence introduction describing its main content, with presentation and organization methods tailored to the target audience.
-
-Processing workflow:
-
-- If user feedback is not in English, translate it to English first to better understand user intent
-- Analyze user feedback to understand the specific intent (add, delete, update, or move sections)
-- Determine which tools to use based on the user's requirements
-- Execute the appropriate operations using available tools
-- Ensure all modifications maintain documentation structure integrity
-- Return 'success' when the latest version of websiteStructure meets user feedback
-
-Rules:
-** All changes must be made using Tools. **
-** Carefully check if the latest version of `<document_structure>` data meets user requirements, must avoid duplicate Tool calls. **
-</instructions>

package/prompts/translate/admonition.md

@@ -1,20 +0,0 @@
-<admonition_rules>
-
-Admonition blocks use the following format:
-
-```
-:::severity
-
-text
-
-:::
-```
-
-Admonition Translation Rules:
-
-- **Translate** the text content only
-- **Do not translate** the severity keyword (success, info, warning, error)
-- **Preserve** the `:::` syntax and block structure
-
-</admonition_rules>
-

package/prompts/translate/code-block.md

@@ -1,33 +0,0 @@
-<code_block_rules>
-The following formats are considered Code Blocks:
-
-- Wrapped with ```
-- Supports configurations: language, optional title, optional icon (icon uses key=value)
-- title is free text placed after the language (not as title=xxx), may contain spaces, and **must NEVER be wrapped in quotes**
-- content can be code, command line examples, text or any other content
-
-<code_block_sample>
-
-- `language`: javascript
-- `title`: Modern: Using createRoot()
-- `icon`: logos:javascript
-
-```javascript Modern: Using createRoot() icon=logos:javascript
-import { createRoot } from 'react-dom/client'
-
-const container = document.getElementById('root')
-const root = createRoot(container)
-
-root.unmount()
-```
-
-</code_block_sample>
-
-Code Block Translation Rules:
-
-- For D2 code blocks, translate **labels only**; leave all variable names, component names, and syntax unchanged.
-- Translate **comments only** using the language-specific comment syntax; **preserve** all code, variables, functions, and syntax.
-- **Do not translate** command examples, terminal/log outputs, or runtime output.
-- **Preserve** all formatting, indentation, and code block structure.
-
-</code_block_rules>

package/prompts/translate/glossary.md

@@ -1,6 +0,0 @@
-Terminology Reference:
-<glossary>
-- Agent: A system or program capable of autonomously executing tasks.
-- AIGNE: An open-source AI agent framework designed to simplify the development and deployment of AI agents.
-- InputSchema/OutputSchema: Input/output structures that define the structured descriptions for input/output data formats.
-</glossary>