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

package/utils/file-utils.mjs

@@ -900,17 +900,19 @@ export function isDirExcluded(dir, excludePatterns) {
 
 /**
  * Return source paths that would be excluded by exclude patterns (files are skipped, directories use minimatch, glob patterns use path prefix heuristic)
+ * @returns {{excluded: string[], notFound: string[]}} Object with excluded and notFound arrays
  */
 export async function findInvalidSourcePaths(sourcePaths, excludePatterns) {
   if (!Array.isArray(sourcePaths) || sourcePaths.length === 0) {
-    return [];
+    return { excluded: [], notFound: [] };
   }
 
   if (!Array.isArray(excludePatterns) || excludePatterns.length === 0) {
-    return [];
+    return { excluded: [], notFound: [] };
   }
 
-  const invalidPaths = [];
+  const excluded = [];
+  const notFound = [];
 
   for (const sourcePath of sourcePaths) {
     if (typeof sourcePath !== "string" || !sourcePath) {
@@ -931,7 +933,7 @@ export async function findInvalidSourcePaths(sourcePaths, excludePatterns) {
     if (isGlobPattern(sourcePath)) {
       const representativePath = getPathPrefix(sourcePath);
       if (isDirExcluded(representativePath, excludePatterns)) {
-        invalidPaths.push(sourcePath);
+        excluded.push(sourcePath);
       }
       continue;
     }
@@ -945,14 +947,14 @@ export async function findInvalidSourcePaths(sourcePaths, excludePatterns) {
       // Check dir with minimatch
       if (stats.isDirectory()) {
         if (isDirExcluded(sourcePath, excludePatterns)) {
-          invalidPaths.push(sourcePath);
+          excluded.push(sourcePath);
         }
       }
     } catch {
       // Path doesn't exist
-      invalidPaths.push(sourcePath);
+      notFound.push(sourcePath);
     }
   }
 
-  return invalidPaths;
+  return { excluded, notFound };
 }

package/utils/load-config.mjs

@@ -41,11 +41,28 @@ export default async function loadConfig({ config, appUrl }) {
         ...(processedConfig.excludePatterns || parsedConfig.excludePatterns || []),
       ];
 
-      const invalidPaths = await findInvalidSourcePaths(sourcesPath, excludePatterns);
-      if (invalidPaths.length > 0) {
-        console.warn(
-          `⚠️  Some source paths have been excluded and will not be processed:\n${invalidPaths.map((p) => `  - ${chalk.yellow(p)}`).join("\n")}\n💡 Tip: You can remove these paths in ${toDisplayPath(configPath)}\n`,
+      const { excluded, notFound } = await findInvalidSourcePaths(sourcesPath, excludePatterns);
+
+      if (excluded.length > 0 || notFound.length > 0) {
+        const warnings = [];
+
+        if (excluded.length > 0) {
+          warnings.push(
+            `⚠️  These paths were excluded (ignored by config):\n${excluded.map((p) => `  - ${chalk.yellow(p)}`).join("\n")}`,
+          );
+        }
+
+        if (notFound.length > 0) {
+          warnings.push(
+            `🚫 These paths were skipped because they do not exist:\n${notFound.map((p) => `  - ${chalk.red(p)}`).join("\n")}`,
+          );
+        }
+
+        warnings.push(
+          `💡 Tip: You can remove these paths in ${chalk.cyan(toDisplayPath(configPath))}`,
         );
+
+        console.warn(`${warnings.join("\n\n")}\n`);
       }
     }
 

package/utils/markdown-checker.mjs

@@ -59,6 +59,9 @@ function countTableColumns(line) {
   return columns.length;
 }
 
+const linkPattern = /(?<!!)\[([^\]]+)\]\(([^)]+)\)/g;
+const hrefPattern = /<x-card[^>]*\s+data-href\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s>]+))/gi;
+
 /**
  * Check for dead links in markdown content
  * @param {string} markdown - The markdown content
@@ -67,16 +70,33 @@ function countTableColumns(line) {
  * @param {Array} errorMessages - Array to push error messages to
  */
 function checkDeadLinks(markdown, source, allowedLinks, errorMessages) {
-  const linkRegex = /(?<!!)\[([^\]]+)\]\(([^)]+)\)/g;
-  let match;
+  const links = [];
 
+  // Collect Markdown format links: [text](link)
+  const linkRegex = new RegExp(linkPattern.source, linkPattern.flags);
+  let match;
   while (true) {
     match = linkRegex.exec(markdown);
     if (match === null) break;
+    links.push({ trimLink: match[2].trim(), display: `[${match[1]}](${match[2].trim()})` });
+  }
 
-    const link = match[2];
-    const trimLink = link.trim();
+  // Collect data-href attribute values from <x-card> elements
+  const hrefRegex = new RegExp(hrefPattern.source, hrefPattern.flags);
+  let attrMatch;
+  while (true) {
+    attrMatch = hrefRegex.exec(markdown);
+    if (attrMatch === null) break;
+    const attrValue = (attrMatch[1] || attrMatch[2] || attrMatch[3] || "").trim();
+    if (attrValue) {
+      // Preserve original format with quotes if present
+      const originalMatch = attrMatch[0];
+      links.push({ trimLink: attrValue, display: originalMatch });
+    }
+  }
 
+  // Process all collected links with the same logic
+  for (const { trimLink, display } of links) {
     // Only check links that processContent would process
     // Exclude external links and mailto
     if (/^(https?:\/\/|mailto:)/.test(trimLink)) continue;
@@ -90,12 +110,37 @@ function checkDeadLinks(markdown, source, allowedLinks, errorMessages) {
     // Check if this link is in the allowed links set
     if (!allowedLinks.has(path)) {
       errorMessages.push(
-        `Found a dead link in ${source}: [${match[1]}](${trimLink}), ensure the link exists in the documentation structure path`,
+        `Found a dead link in ${source}: ${display}, ensure the link exists in the documentation structure path`,
       );
     }
   }
 }
 
+/**
+ * Extract link from error message
+ * @param {string} error - The error message
+ * @returns {string} - The link
+ */
+export function getLinkFromError(error) {
+  if (!error || !error.includes("Found a dead link in")) {
+    return "";
+  }
+
+  const linkRegex = new RegExp(linkPattern.source, linkPattern.flags);
+  let match = linkRegex.exec(error);
+  if (match) {
+    return match[2].trim();
+  }
+
+  const hrefRegex = new RegExp(hrefPattern.source, hrefPattern.flags);
+  match = hrefRegex.exec(error);
+  if (match) {
+    return (match[1] || match[2] || match[3] || "").trim();
+  }
+
+  return "";
+}
+
 /**
  * Check code block content for indentation consistency issues
  * @param {Array} codeBlockContent - Array of {line, lineNumber} objects from the code block

package/utils/utils.mjs

@@ -1225,3 +1225,106 @@ export function getContentHash(str, { trim = true } = {}) {
   const input = trim && typeof str === "string" ? str.trim() : str;
   return crypto.createHash("sha256").update(input).digest("hex");
 }
+
+function toPath(path) {
+  if (Array.isArray(path)) return path;
+
+  const result = [];
+  path.replace(/[^.[\]]+|\[(\d+|(["'])(.*?)\2)\]/g, (match, bracketContent, quote, quotedKey) => {
+    if (quote) {
+      // ["key"] or ['key']
+      result.push(quotedKey);
+    } else if (bracketContent !== undefined) {
+      // [123]
+      result.push(bracketContent);
+    } else {
+      // dot notation
+      result.push(match);
+    }
+  });
+  return result;
+}
+
+/**
+ * Deeply get the value at a given path from an object, or return a default value if missing.
+ * @param {object} obj - The object to query.
+ * @param {string|Array<string|number>} path - The path to get, as a string or array.
+ * @param {*} defaultValue - The value returned if the resolved value is undefined.
+ * @returns {*} The value at the path or defaultValue.
+ */
+export function dget(obj, path, defaultValue) {
+  const parts = toPath(path);
+
+  let current = obj;
+  for (const key of parts) {
+    if (current == null || !(key in current)) return defaultValue;
+    current = current[key];
+  }
+  return current;
+}
+
+/**
+ * Deeply set the value at a given path in an object.
+ * @param {object} obj - The object to modify.
+ * @param {string|Array<string|number>} path - The path to set, as a string or array.
+ * @param {*} value - The value to set.
+ * @returns {object} The modified object.
+ */
+export function dset(obj, path, value) {
+  const parts = toPath(path);
+
+  let current = obj;
+  for (let i = 0; i < parts.length; i++) {
+    const key = parts[i];
+
+    if (i === parts.length - 1) {
+      current[key] = value;
+    } else {
+      if (current[key] == null || typeof current[key] !== "object") {
+        current[key] = String(parts[i + 1]).match(/^\d+$/) ? [] : {};
+      }
+      current = current[key];
+    }
+  }
+  return obj;
+}
+
+/**
+ * Create a context path manager that provides get/set/clear operations
+ * @param {object} options - The options object containing user context
+ * @param {string} path - The context path (e.g., 'currentPageDetails./about' or 'lastToolInputs./about')
+ * @returns {object} An object with { get, set } methods and a contextPath method for sub-paths
+ */
+export function userContextAt(options, path) {
+  const userContext = options?.context?.userContext || null;
+  if (!userContext) {
+    throw new Error("userContext is not available");
+  }
+
+  return {
+    /**
+     * Get a value from the context path
+     * @param {string} [key] - Optional key for nested access (e.g., 'updateMeta' for lastToolInputs)
+     * @returns {*} The value at the path, or undefined if not found
+     */
+    get(key) {
+      if (key !== undefined) {
+        return dget(userContext, `${path}.${key}`);
+      }
+      return dget(userContext, path);
+    },
+
+    /**
+     * Set a value in the context path
+     * @param {string|*} key - If key is provided, this is the key; otherwise this is the value
+     * @param {*} [value] - The value to set (required if first param is a key)
+     */
+    set(key, value) {
+      if (value !== undefined) {
+        dset(userContext, `${path}.${key}`, value);
+      } else {
+        dset(userContext, path, key);
+      }
+    },
+  };
+}

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

@@ -1,55 +0,0 @@
-<role>
-You are a feedback intent analyzer. Your task is to determine whether data sources are needed to fulfill the user's feedback about content modifications.
-</role>
-
-<input>
-- feedback: {{feedback}}
-</input>
-
-<analysis_rules>
-**Determining Data Source Necessity:**
-
-You need to analyze the user's feedback and categorize it into different intent types. Based on the intent type, determine if data sources are required.
-
-This analyzer is generic and can be used for any content modification scenarios (documentation structure, document content, translations, etc.).
-
-**Intent Types:**
-
-1. **add** - Adding new items, sections, or content
-   - Requires data sources: **YES**
-   - Reason: Need sufficient context from codebase or related materials to generate accurate new content
-
-2. **edit** - Modifying existing content, descriptions, titles, or properties
-   - Requires data sources: **YES**
-   - Reason: Need context to ensure modifications are accurate and contextually appropriate
-
-3. **delete** - Removing items, sections, or content
-   - Requires data sources: **NO**
-   - Reason: Deletion only needs to identify what to remove, no new content generation needed
-
-4. **move** - Moving items to different positions or parent sections
-   - Requires data sources: **NO**
-   - Reason: Only changing item location in the structure, no content changes needed
-
-5. **reorder** - Changing the order of items at the same level
-   - Requires data sources: **NO**
-   - Reason: Only rearranging sequence, no content generation needed
-
-6. **mixed** - Combination of multiple intent types
-   - Requires data sources: **Depends on whether add/edit operations are included**
-   - Reason: If the feedback includes any add or edit operations, data sources are needed
-
-**Decision Logic:**
-- If the feedback contains ANY add or edit operations → `needDataSources = true`
-- If the feedback ONLY contains delete, move, or reorder operations → `needDataSources = false`
-- When in doubt, default to `needDataSources = true` to ensure sufficient context
-</analysis_rules>
-
-<output_rules>
-Return a JSON object with:
-- `needDataSources`: boolean indicating if data sources are required
-- `intentType`: the primary intent type (add, edit, delete, move, reorder, or mixed)
-- `reason`: clear explanation of why data sources are or aren't needed
-
-Analyze the feedback carefully and be conservative - when uncertain, prefer `needDataSources: true` to ensure sufficient context is available.
-</output_rules>