@aigne/doc-smith 0.9.10 → 0.9.11-beta

package/prompts/utils/analyze-structure-feedback-intent.md

@@ -1,43 +0,0 @@
-<role>
-You are a feedback intent analyzer for **document structure modifications**. Your task is to determine the intent type of user feedback regarding document-level operations and whether external data sources are needed.
-</role>
-
-<input>
-feedback: {{feedback}}
-</input>
-
-<analysis_rules>
-Scope: Only analyze feedback related to document structure. Ignore any content-level operations inside document (e.g. sections, text, images).
-
-**intent types:**
-
-1. add - Adding new documents
-2. edit - Modifying document-level properties (e.g., path, parentId, title of the document itself)
-3. delete - Removing documents
-4. move - Moving documents to different positions or parent sections
-5. reorder - Changing the order of documents
-6. mixed - Combination of multiple intent types
-
-**Data source rules:**
-
-- add/edit -> needDataSources = true
-- delete/move/reorder -> needDataSources = false
-- mixed -> needDataSources = true if any add/edit is included
-
-**Decision logic:**
-
-- Only consider document-level operations in the feedback.
-- If any add or edit operation exists -> needDataSources = true
-- If only delete, move, or reorder operations exist -> needDataSources = false
-- When uncertain, default to needDataSources = true
-</analysis_rules>
-
-<output_rules>
-Return a JSON object:
-
-{
-  "needDataSources": boolean,
-  "intentType": "add" | "edit" | "delete" | "move" | "reorder" | "mixed",
-  "reason": "Explanation of why data sources are or aren't needed based on document-level operations."
-}
-</output_rules>

package/prompts/utils/feedback-refiner.md

@@ -1,105 +0,0 @@
-<role>
-You are a "Feedback→Rule" converter. Transform one-time natural language feedback into a **single sentence**, **executable**, **reusable** instruction, and determine whether it needs **persistent saving**, along with its scope (global/structure/document/translation) and whether it should be limited to "input paths range".
-</role>
-
-<input>
-- feedback: {{feedback}}
-- stage: {{stage}}      # Possible values: document_structure | document_refine | translation_refine
-- paths: {{paths}}      # Array of paths input in current command (can be empty). Used only to determine whether to "limit to these paths". Do not include them in output.
-- existingPreferences: {{existingPreferences}}      # Currently saved user preference rules
-</input>
-
-<scope_rules>
-Scope determination heuristic rules:
-
-**Classification by stage**:
-- If stage=document_structure: Default `scope="structure"`, unless feedback is clearly global writing/tone/exclusion policy (then use `global`).
-- If stage=document_refine: Default `scope="document"`; if feedback is general writing policy or exclusion strategy that doesn't depend on specific pages, can be elevated to `global`.
-- If stage=translation_refine: Default `scope="translation"`; if feedback is general translation policy, maintain this scope.
-
-**Path Limitation (`limitToInputPaths`) Determination**:
-- **Set to `true` IF** the feedback explicitly names a specific document, path, or section (e.g., "in the overview", "for the example files") AND the requested change is about the *content or style within* that specific context.
-- **Set to `false` IF** the feedback describes a general policy (e.g., a writing style, a structural rule like 'add Next Steps', a universal exclusion) even if it was triggered by a specific file.
-- **Tie-breaker**: When in doubt, default to `false` to create a more broadly applicable rule.
-
-- **Never** return specific paths lists in output.
-</scope_rules>
-
-<save_rules>
-Save determination rules:
-
-**Primary Goal: Your most critical task is to distinguish between a reusable policy and a one-time fix. Be conservative: when in doubt, default to `save=false`.**
-
-**One-time operations (do not save)**:
-- Only corrects current version/typos/individual phrasing/local factual errors with no stable reusable value → `save=false`
-- Fixes that are highly specific to a single line or data point and unlikely to recur (e.g., "change the year from 2020 to 2021") → `save=false`
-- Documentation Structure adjustments, adding new documents, update document, delete document, and moving document positions are always one-time operations → `save=false`
-
-**Reusable policies (save)**:
-- Writing styles, structural conventions, translation conventions that are broadly applicable and should be consistently executed in the future → `save=true`
-
-**Duplication check (do not save)**:
-- If `existingPreferences` already contains **similar or covering** rules for current feedback intent, then `save=false`
-- Check logic: Compare feedback intent, rule meaning, and applicable scope. If new feedback is already sufficiently covered by existing rules, no need to save duplicates
-- If new feedback is **refinement, supplement, or conflicting correction** to existing rules, it can still be `save=true`
-
-**Determination principle**:
-- Prioritize avoiding duplicate saves; if difficult to determine whether duplicate, prioritize `save=false` to avoid rule redundancy
-</save_rules>
-
-<rule_format>
-Rule writing requirements:
-
-- Model-oriented **single sentence** instruction; allow using clear wording like "must/must not/always".
-- Do not introduce specific paths or bind to specific file names.
-- **Crucially, preserve specific, domain-related keywords** (e.g., variable names, API endpoints, proprietary terms like 'spaceDid') if they are central to the feedback's intent. Generalize the *action*, not the *subject*.
-- **If the feedback is about deleting or removing content, the resulting rule must be a preventative, forward-looking instruction.** Rephrase it as "Do not generate..." or "Avoid including content about...".
-- Example: "Write for beginners; terms must be given clear explanations on first appearance."
-</rule_format>
-
-<output_rules>
-Return a complete JSON object with a `reason` field explaining *why* you are setting `save` to true or false, and how you derived the rule and scope.
-Return the summarized rule in the same language as the feedback in user input.
-</output_rules>
-
-<feedback_processing_examples>
-Example 1 (Keyword Preservation):
-- Input: stage=document_refine, paths=["examples/demo.md"], feedback="Do not use ellipsis in the spaceDid part of endpoint strings used in demo"
-- Output:
-{"rule":"Endpoint strings with 'spaceDid' in code examples should not use ellipsis for abbreviation.","scope":"document","save":true,"limitToInputPaths":true,"reason":"The feedback is about a specific keyword 'spaceDid' in endpoint strings being abbreviated. This is a recurring style issue that should be a policy. It's a reusable rule, so `save` is `true`. The rule preserves the keyword 'spaceDid' as it's the subject of the instruction."}
-
-Example 2:
-- Input: stage=document_structure, paths=[], feedback="Add 'Next Steps' at the end of overview and tutorials with 2-3 links."
-- Output:
-{"rule":"Add 'Next Steps' section at the end of overview and tutorial documents with 2-3 links within the repository.","scope":"structure","save":false,"limitToInputPaths":false,"reason":"This feedback is about adjusting document structure by adding a new section. According to save rules, documentation structure adjustments are always one-time operations, so `save` should be `false`. The scope remains `structure` as it affects document organization."}
-
-Example 3:
-- Input: stage=translation_refine, paths=[], feedback="Don't translate variable names and code."
-- Output:
-{"rule":"Keep code and identifiers unchanged during translation, must not translate them.","scope":"translation","save":true,"limitToInputPaths":false,"reason":"This is a fundamental, reusable policy for all future translations in this project. It's not a one-time fix. So, `save` is `true` and the scope is correctly `translation`."}
-
-Example 4 (One-time Fix):
-- Input: stage=document_refine, paths=["overview.md"], feedback="This paragraph has factual errors, change it to released in 2021."
-- Output:
-{"rule":"Correct facts to the accurate year.","scope":"document","save":false,"limitToInputPaths":true,"reason":"The feedback is a one-time factual correction for the current content. It corrects a specific data point and is not a reusable writing policy for the future. Therefore, `save` should be `false`."}
-
-Example 5 (Deduplication):
-- Input: stage=document_refine, paths=[], feedback="Code examples are too complex, simplify them.", existingPreferences="rules:\n  - rule: Example pages should focus on minimally runnable code, removing explanatory sections unrelated to the topic.\n    scope: document\n    active: true"
-- Output:
-{"rule":"Simplify the complexity of code examples.","scope":"document","save":false,"limitToInputPaths":false,"reason":"The user wants to simplify code examples. The existing preference rule 'Example pages should focus on minimally runnable code' already covers this intent. Saving a new, similar rule would be redundant. Therefore, `save` should be `false`."}
-
-Example 6 (Non-duplication):
-- Input: stage=document_refine, paths=[], feedback="Code comments should be written in English.", existingPreferences="rules:\n  - rule: Example pages should focus on minimally runnable code, removing explanatory sections unrelated to the topic.\n    scope: document\n    active: true"
-- Output:
-{"rule":"Code comments must be written in English.","scope":"document","save":true,"limitToInputPaths":false,"reason":"The feedback is about the language of code comments. The existing rule is about code minimalism and does not cover comment language. This is a new, non-overlapping rule. Thus, it should be saved. `save` is `true`."}
-
-Example 7 (Deletion Handling):
-- Input: stage=document_structure, paths=[], feedback="The 'Legacy API Reference' document is outdated and should be removed."
-- Output:
-{"rule":"Do not generate documents or sections for outdated 'Legacy API Reference'.","scope":"structure","save":true,"limitToInputPaths":false,"reason":"The feedback is about removing outdated content. Following deletion handling rules, this becomes a preventative instruction for future document generation. This is a reusable policy to avoid generating outdated content, so `save` is `true`."}
-
-Example 8 (Path-limited Deletion Rule):
-- Input: stage=document_refine, paths=["overview.md"], feedback="Remove contribution-related content from overview"
-- Output:
-{"rule":"Do not include contribution-related content in 'overview' document.","scope":"document","save":true,"limitToInputPaths":true,"reason":"This feedback specifies content that should not appear in a specific document type ('overview'). While it's about removing content, we convert it to a preventative rule. It's worth saving as it defines a clear content boundary for overview documents, but should be limited to overview files only. Therefore `save` is `true` with `limitToInputPaths` also `true`."}
-</feedback_processing_examples>

package/types/document-schema.mjs

@@ -1,55 +0,0 @@
-import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
-
-// Update document content schemas
-export const updateDocumentContentInputSchema = z.object({
-  diffPatch: z.string().min(1, "Diff patch is required"),
-  path: z.string().min(1, "Path is required for concurrent document updates"),
-});
-
-export const updateDocumentContentOutputSchema = z.object({
-  success: z.boolean(),
-  updatedContent: z.string().optional(),
-  error: z.object({ message: z.string() }).optional(),
-  message: z.string().optional(),
-});
-
-// JSON Schema conversions for update document content
-export const getUpdateDocumentContentInputJsonSchema = () => {
-  const schema = zodToJsonSchema(updateDocumentContentInputSchema);
-  if (schema.properties) {
-    schema.properties.diffPatch.description = "Diff patch string to apply to the original content";
-    schema.properties.path.description = "Document path";
-  }
-  return schema;
-};
-
-export const getUpdateDocumentContentOutputJsonSchema = () => {
-  const schema = zodToJsonSchema(updateDocumentContentOutputSchema);
-  if (schema.properties) {
-    schema.properties.success.description = "Whether the update was successful";
-    schema.properties.updatedContent.description =
-      "Updated markdown content (only present if success is true)";
-    schema.properties.error.description =
-      "Error object containing error message (only present if success is false)";
-    schema.properties.message.description = "Success message (only present if success is true)";
-  }
-  return schema;
-};
-
-// Validation helper for update document content
-export const validateUpdateDocumentContentInput = (input) => {
-  try {
-    return {
-      success: true,
-      data: updateDocumentContentInputSchema.parse(input),
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error:
-        error.errors?.map((err) => `${err.path.join(".")}: ${err.message}`).join(", ") ||
-        error.message,
-    };
-  }
-};

package/types/document-structure-schema.mjs

@@ -1,261 +0,0 @@
-import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
-
-// Document item schema - represents a single document in the structure
-export const documentItemSchema = z.object({
-  title: z.string().min(1, "Title is required"),
-  description: z.string().min(1, "Description is required"),
-  path: z.string().startsWith("/", 'Path must start with "/"'),
-  parentId: z.string().nullish(),
-  sourceIds: z.array(z.string()).min(1, "At least one source ID is required"),
-  icon: z.string().optional(), // Lucide icon name (e.g., lucide:book) for root-level documents
-});
-
-// Documentation structure schema - represents the entire documentation structure array
-export const documentStructureSchema = z.array(documentItemSchema);
-
-// Add document schemas
-export const addDocumentInputSchema = z.object({
-  title: z.string().min(1, "Title is required"),
-  description: z.string().min(1, "Description is required"),
-  path: z.string().startsWith("/", 'Path must start with "/"'),
-  parentId: z.string().nullish(),
-  sourceIds: z.array(z.string()).min(1, "At least one source ID is required"),
-});
-
-export const addDocumentOutputSchema = z.object({
-  documentStructure: documentStructureSchema,
-  message: z.string().optional(),
-  addedDocument: documentItemSchema.optional(),
-  error: z.object({ message: z.string() }).optional(),
-});
-
-// Delete document schemas
-export const deleteDocumentInputSchema = z.object({
-  path: z.string().min(1, "Path is required"),
-  recursive: z.boolean().optional(),
-});
-
-export const deleteDocumentOutputSchema = z.object({
-  documentStructure: documentStructureSchema,
-  message: z.string().optional(),
-  deletedDocuments: z.array(documentItemSchema).optional(),
-  error: z.object({ message: z.string() }).optional(),
-});
-
-// Move document schemas
-export const moveDocumentInputSchema = z.object({
-  path: z.string().min(1, "Path is required"),
-  newParentId: z.string().nullish(),
-});
-
-export const moveDocumentOutputSchema = z.object({
-  documentStructure: documentStructureSchema,
-  message: z.string().optional(),
-  originalDocument: documentItemSchema.optional(),
-  updatedDocument: documentItemSchema.optional(),
-  error: z.object({ message: z.string() }).optional(),
-});
-
-// Update document schemas
-export const updateDocumentInputSchema = z
-  .object({
-    path: z.string().min(1, "Path is required"),
-    title: z.string().min(1).optional(),
-    description: z.string().min(1).optional(),
-    sourceIds: z.array(z.string()).min(1).optional(),
-  })
-  .refine(
-    (data) =>
-      data.title !== undefined || data.description !== undefined || data.sourceIds !== undefined,
-    {
-      message: "At least one field (title, description, or sourceIds) must be provided for update",
-    },
-  );
-
-export const updateDocumentOutputSchema = z.object({
-  documentStructure: documentStructureSchema,
-  message: z.string().optional(),
-  originalDocument: documentItemSchema.optional(),
-  updatedDocument: documentItemSchema.optional(),
-  error: z.object({ message: z.string() }).optional(),
-});
-
-// JSON Schema conversion functions using zodToJsonSchema
-export const getAddDocumentInputJsonSchema = () => {
-  const schema = zodToJsonSchema(addDocumentInputSchema);
-  // Add custom descriptions
-  if (schema.properties) {
-    schema.properties.title.description = "Title of the new document";
-    schema.properties.description.description = "Description of the new document";
-    schema.properties.path.description = "URL path for the new document (must start with '/')";
-    schema.properties.parentId.description =
-      "Parent document path (leave empty for top-level documents)";
-    schema.properties.sourceIds.description =
-      "Source references from associated data sources (required)";
-  }
-  return schema;
-};
-
-export const getAddDocumentOutputJsonSchema = () => {
-  const schema = zodToJsonSchema(addDocumentOutputSchema);
-  if (schema.properties) {
-    schema.properties.documentStructure.description =
-      "Updated documentation structure array with the new document added";
-    schema.properties.message.description = "Success message describing the operation result";
-    schema.properties.addedDocument.description = "The newly added document object";
-    schema.properties.error.description =
-      "Error object containing error message if operation failed";
-  }
-  return schema;
-};
-
-export const getDeleteDocumentInputJsonSchema = () => {
-  const schema = zodToJsonSchema(deleteDocumentInputSchema);
-  if (schema.properties) {
-    schema.properties.path.description = "URL path of the document to delete";
-    schema.properties.recursive.description =
-      "If true, recursively delete all child documents. If false or not provided, deletion will fail if child documents exist.";
-  }
-  return schema;
-};
-
-export const getDeleteDocumentOutputJsonSchema = () => {
-  const schema = zodToJsonSchema(deleteDocumentOutputSchema);
-  if (schema.properties) {
-    schema.properties.documentStructure.description =
-      "Updated documentation structure array with the document removed";
-    schema.properties.message.description = "Success message describing the operation result";
-    schema.properties.deletedDocuments.description =
-      "Array of deleted document objects (includes all recursively deleted child documents if recursive=true)";
-    schema.properties.error.description =
-      "Error object containing error message if operation failed";
-  }
-  return schema;
-};
-
-export const getMoveDocumentInputJsonSchema = () => {
-  const schema = zodToJsonSchema(moveDocumentInputSchema);
-  if (schema.properties) {
-    schema.properties.path.description = "URL path of the document to move";
-    schema.properties.newParentId.description =
-      "Path of the new parent document (leave empty for top-level)";
-  }
-  return schema;
-};
-
-export const getMoveDocumentOutputJsonSchema = () => {
-  const schema = zodToJsonSchema(moveDocumentOutputSchema);
-  if (schema.properties) {
-    schema.properties.documentStructure.description =
-      "Updated documentation structure array with the document moved";
-    schema.properties.message.description = "Success message describing the operation result";
-    schema.properties.originalDocument.description = "The original document object before moving";
-    schema.properties.updatedDocument.description = "The updated document object after moving";
-    schema.properties.error.description =
-      "Error object containing error message if operation failed";
-  }
-  return schema;
-};
-
-export const getUpdateDocumentInputJsonSchema = () => {
-  const schema = zodToJsonSchema(updateDocumentInputSchema);
-  if (schema.properties) {
-    schema.properties.path.description = "URL path of the document to update";
-    schema.properties.title.description = "New title for the document (optional)";
-    schema.properties.description.description = "New description for the document (optional)";
-    schema.properties.sourceIds.description =
-      "New source references for the document (optional, cannot be empty if provided)";
-  }
-  // Add anyOf constraint for at least one update field
-  schema.anyOf = [
-    { required: ["title"] },
-    { required: ["description"] },
-    { required: ["sourceIds"] },
-  ];
-  return schema;
-};
-
-export const getUpdateDocumentOutputJsonSchema = () => {
-  const schema = zodToJsonSchema(updateDocumentOutputSchema);
-  if (schema.properties) {
-    schema.properties.documentStructure.description =
-      "Updated documentation structure array with the document modified";
-    schema.properties.message.description = "Success message describing the operation result";
-    schema.properties.originalDocument.description = "The original document object before update";
-    schema.properties.updatedDocument.description =
-      "The updated document object after modification";
-    schema.properties.error.description =
-      "Error object containing error message if operation failed";
-  }
-  return schema;
-};
-
-// Validation helper functions
-export const validateAddDocumentInput = (input) => {
-  try {
-    return {
-      success: true,
-      data: addDocumentInputSchema.parse(input),
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error:
-        error.errors?.map((err) => `${err.path.join(".")}: ${err.message}`).join(", ") ||
-        error.message,
-    };
-  }
-};
-
-export const validateDeleteDocumentInput = (input) => {
-  try {
-    return {
-      success: true,
-      data: deleteDocumentInputSchema.parse(input),
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error:
-        error.errors?.map((err) => `${err.path.join(".")}: ${err.message}`).join(", ") ||
-        error.message,
-    };
-  }
-};
-
-export const validateMoveDocumentInput = (input) => {
-  try {
-    return {
-      success: true,
-      data: moveDocumentInputSchema.parse(input),
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error:
-        error.errors?.map((err) => `${err.path.join(".")}: ${err.message}`).join(", ") ||
-        error.message,
-    };
-  }
-};
-
-export const validateUpdateDocumentInput = (input) => {
-  try {
-    return {
-      success: true,
-      data: updateDocumentInputSchema.parse(input),
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error:
-        error.errors?.map((err) => `${err.path.join(".")}: ${err.message}`).join(", ") ||
-        error.message,
-    };
-  }
-};
-
-// Type inference helpers for better IDE support
-export const createDocumentItem = (data) => documentItemSchema.parse(data);
-export const createDocumentStructure = (data) => documentStructureSchema.parse(data);

package/utils/check-document-has-diagram.mjs

@@ -1,95 +0,0 @@
-import { DIAGRAM_PLACEHOLDER, d2CodeBlockRegex, diagramImageStartRegex } from "./d2-utils.mjs";
-
-/**
- * Check if document content contains diagram-related content
- * @param {string} content - Document content to check
- * @returns {boolean} - True if document contains d2 code blocks, DIAGRAM_PLACEHOLDER, or diagram images
- */
-export function hasDiagramContent(content) {
-  if (!content || typeof content !== "string") {
-    return false;
-  }
-
-  // Check for DIAGRAM_PLACEHOLDER
-  if (content.includes(DIAGRAM_PLACEHOLDER)) {
-    return true;
-  }
-
-  // Check for D2 code blocks
-  const d2Matches = Array.from(content.matchAll(d2CodeBlockRegex));
-  if (d2Matches.length > 0) {
-    return true;
-  }
-
-  // Check for existing diagram images (DIAGRAM_IMAGE_START markers)
-  const imageMatches = Array.from(content.matchAll(diagramImageStartRegex));
-  if (imageMatches.length > 0) {
-    return true;
-  }
-
-  return false;
-}
-
-/**
- * Get diagram type labels for a document
- * @param {string} content - Document content to analyze
- * @returns {string[]} - Array of diagram type labels (e.g., ["D2", "AI Image", "Placeholder"])
- */
-export function getDiagramTypeLabels(content) {
-  if (!content || typeof content !== "string") {
-    return [];
-  }
-
-  const labels = [];
-
-  // Check for D2 code blocks
-  const d2Matches = Array.from(content.matchAll(d2CodeBlockRegex));
-  if (d2Matches.length > 0) {
-    labels.push("⛔️ D2");
-  }
-
-  // Check for existing diagram images (AI-generated images)
-  const imageMatches = Array.from(content.matchAll(diagramImageStartRegex));
-  if (imageMatches.length > 0) {
-    labels.push("🍌 Image");
-  }
-
-  // Check for DIAGRAM_PLACEHOLDER
-  if (content.includes(DIAGRAM_PLACEHOLDER)) {
-    labels.push("Placeholder");
-  }
-
-  return labels;
-}
-
-/**
- * Format diagram type labels as a suffix string
- * @param {string[]} labels - Array of diagram type labels
- * @returns {string} - Formatted suffix string (e.g., " [D2, AI Image]")
- */
-export function formatDiagramTypeSuffix(labels) {
-  if (!labels || labels.length === 0) {
-    return "";
-  }
-  return ` [${labels.join(", ")}]`;
-}
-
-/**
- * Check if document content contains banana images (AI-generated images)
- * Only checks for DIAGRAM_IMAGE_START markers, excludes D2 code blocks and placeholders
- * @param {string} content - Document content to check
- * @returns {boolean} - True if document contains banana images
- */
-export function hasBananaImages(content) {
-  if (!content || typeof content !== "string") {
-    return false;
-  }
-
-  // Check for existing diagram images (DIAGRAM_IMAGE_START markers)
-  const imageMatches = Array.from(content.matchAll(diagramImageStartRegex));
-  if (imageMatches.length > 0) {
-    return true;
-  }
-
-  return false;
-}