@aigne/doc-smith 0.2.11 → 0.3.1

package/tests/test-all-validation-cases.mjs

@@ -495,6 +495,28 @@ flowchart TD
     OperationalExcellence --> "Maintainability & Scalability" --> L;
 \`\`\`
 
+This content ends properly.
+`,
+  },
+
+  {
+    category: "🧩 MERMAID VALIDATION",
+    name: "Mermaid with numbered list format in node labels",
+    expectPass: false,
+    expectedErrors: ["numbered list format in Mermaid node label"],
+    content: `# Test Document
+
+\`\`\`mermaid
+flowchart TD
+    A["1. Create Backend Implementation<br>api/src/providers/"]
+    B["2. Add Backend Configuration<br>api/src/providers/models.ts"]
+    C["3. Update Frontend Selector<br>src/pages/config/ai-providers/"]
+    D["4. Add Provider Logo<br>public/logo/"]
+    E["5. Update Documentation"]
+
+    A --> B --> C --> D --> E
+\`\`\`
+
 This content ends properly.
 `,
   },

package/utils/auth-utils.mjs

@@ -3,11 +3,20 @@ import { readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createConnect } from "@aigne/aigne-hub";
+import chalk from "chalk";
 import open from "open";
 import { joinURL } from "ufo";
 import { parse, stringify } from "yaml";
-import { getComponentMountPoint } from "./blocklet.mjs";
-import { DISCUSS_KIT_DID } from "./constants.mjs";
+import {
+  getComponentMountPoint,
+  InvalidBlockletError,
+  ComponentNotFoundError,
+} from "./blocklet.mjs";
+import {
+  DISCUSS_KIT_DID,
+  DISCUSS_KIT_STORE_URL,
+  BLOCKLET_ADD_COMPONENT_DOCS,
+} from "./constants.mjs";
 
 const WELLKNOWN_SERVICE_PATH_PREFIX = "/.well-known/service";
 
@@ -47,14 +56,29 @@ export async function getAccessToken(appUrl) {
   // Check if Discuss Kit is running at the provided URL
   try {
     await getComponentMountPoint(appUrl, DISCUSS_KIT_DID);
-  } catch {
-    throw new Error(
-      `Unable to find Discuss Kit running at the provided URL: ${appUrl}\n\n` +
-        "Please ensure that:\n" +
-        "• The URL is correct and accessible\n" +
-        "• Discuss Kit is properly installed and running\n" +
-        "If you continue to experience issues, please verify your Discuss Kit installation.",
-    );
+  } catch (error) {
+    const storeLink = chalk.cyan(DISCUSS_KIT_STORE_URL);
+    if (error instanceof InvalidBlockletError) {
+      throw new Error(
+        `${chalk.yellow("⚠️  The provided URL is not a valid website on ArcBlock platform")}\n\n` +
+          `${chalk.bold("💡 Solution:")} Start here to run your own website that can host your docs:\n${storeLink}\n\n`,
+      );
+    } else if (error instanceof ComponentNotFoundError) {
+      const docsLink = chalk.cyan(BLOCKLET_ADD_COMPONENT_DOCS);
+      throw new Error(
+        `${chalk.yellow("⚠️  This website does not have required components for publishing")}\n\n` +
+          `${chalk.bold("💡 Solution:")} Please refer to the documentation to add Discuss Kit component:\n${docsLink}\n\n`,
+      );
+    } else {
+      throw new Error(
+        `❌ Unable to connect to: ${chalk.cyan(appUrl)}\n\n` +
+          `${chalk.bold("Possible causes:")}\n` +
+          `• Network connection issues\n` +
+          `• Server temporarily unavailable\n` +
+          `• Incorrect URL address\n\n` +
+          `${chalk.green("Suggestion:")} Please check your network connection and URL address, then try again`,
+      );
+    }
   }
 
   const DISCUSS_KIT_URL = appUrl;

package/utils/blocklet.mjs

@@ -1,24 +1,58 @@
+/**
+ * Custom error class for invalid blocklet application URLs
+ */
+export class InvalidBlockletError extends Error {
+  constructor(url, status, statusText) {
+    super(`Invalid application URL: "${url}". Unable to fetch configuration.`);
+    this.name = "InvalidBlockletError";
+    this.url = url;
+    this.status = status;
+    this.statusText = statusText;
+  }
+}
+
+/**
+ * Custom error class for missing component mount points
+ */
+export class ComponentNotFoundError extends Error {
+  constructor(did, appUrl) {
+    super(`Your website "${appUrl}" missing required component to host your docs.`);
+    this.name = "ComponentNotFoundError";
+    this.did = did;
+    this.appUrl = appUrl;
+  }
+}
+
 export async function getComponentMountPoint(appUrl, did) {
   const url = new URL(appUrl);
   const blockletJsUrl = `${url.origin}/__blocklet__.js?type=json`;
 
-  const blockletJs = await fetch(blockletJsUrl, {
-    method: "GET",
-    headers: {
-      Accept: "application/json",
-    },
-  });
+  let blockletJs;
+  try {
+    blockletJs = await fetch(blockletJsUrl, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+  } catch (error) {
+    throw new InvalidBlockletError(appUrl, null, error.message);
+  }
 
   if (!blockletJs.ok) {
-    throw new Error(
-      `Failed to fetch blocklet json: ${blockletJs.status} ${blockletJs.statusText}, ${blockletJsUrl}`,
-    );
+    throw new InvalidBlockletError(appUrl, blockletJs.status, blockletJs.statusText);
+  }
+
+  let config;
+  try {
+    config = await blockletJs.json();
+  } catch {
+    throw new InvalidBlockletError(appUrl, null, "Invalid JSON response");
   }
 
-  const config = await blockletJs.json();
-  const component = config.componentMountPoints.find((component) => component.did === did);
+  const component = config.componentMountPoints?.find((component) => component.did === did);
   if (!component) {
-    throw new Error(`Component ${did} not found in blocklet: ${appUrl}`);
+    throw new ComponentNotFoundError(did, appUrl);
   }
 
   return component.mountPoint;

package/utils/conflict-detector.mjs

@@ -0,0 +1,131 @@
+import { CONFLICT_RULES } from "./constants.mjs";
+
+/**
+ * Detect internal conflicts within the same question (multi-select conflicts)
+ * @param {string} questionType - Question type (documentPurpose, targetAudienceTypes)
+ * @param {Array} selectedValues - User selected values
+ * @returns {Array} List of conflicts
+ */
+export function detectInternalConflicts(questionType, selectedValues) {
+  const rules = CONFLICT_RULES.internalConflicts[questionType] || [];
+
+  // Extract values from the selected items (handle both string arrays and object arrays)
+  const selectedValueStrings = selectedValues.map((item) =>
+    typeof item === "object" && item.value ? item.value : item,
+  );
+
+  const conflicts = [];
+
+  rules.forEach((rule) => {
+    // Check if all conflict items are selected
+    const hasConflict = rule.conflictItems.every((item) => selectedValueStrings.includes(item));
+
+    if (hasConflict) {
+      conflicts.push({
+        type: "internal",
+        questionType,
+        severity: rule.severity,
+        reason: rule.reason,
+        suggestion: rule.suggestion,
+        items: rule.conflictItems,
+      });
+    }
+  });
+
+  return conflicts;
+}
+
+/**
+ * Get filtered options based on cross-question conflict rules
+ * @param {string} targetQuestion - Target question type to filter
+ * @param {Object} currentSelections - Current user selections across all questions
+ * @param {Object} allOptions - All available options for the target question
+ * @returns {Object} Filtered options
+ */
+export function getFilteredOptions(targetQuestion, currentSelections, allOptions) {
+  const crossRules = CONFLICT_RULES.crossConflicts;
+  const filteredOptions = { ...allOptions };
+  const appliedFilters = [];
+
+  crossRules.forEach((rule) => {
+    // Check if we should apply this rule for filtering the target question
+    const shouldApplyRule = (() => {
+      // Check if this rule applies to the target question
+      const conflictingForTarget = rule.conflictingOptions[targetQuestion];
+      if (!conflictingForTarget) {
+        return false;
+      }
+
+      // Check if current selections match the conditions that would trigger filtering
+      const nonTargetConditions = Object.entries(rule.conditions).filter(
+        ([key]) => key !== targetQuestion,
+      );
+
+      if (nonTargetConditions.length === 0) {
+        return false;
+      }
+
+      const matchesNonTargetConditions = nonTargetConditions.every(([key, values]) => {
+        const selection = currentSelections[key];
+        if (!selection) return false;
+
+        // Extract values if selection contains objects
+        const selectionArray = Array.isArray(selection) ? selection : [selection];
+        const selectionValues = selectionArray.map((item) =>
+          typeof item === "object" && item.value ? item.value : item,
+        );
+
+        return values.some((value) => selectionValues.includes(value));
+      });
+
+      return matchesNonTargetConditions;
+    })();
+
+    if (shouldApplyRule && rule.action === "filter") {
+      // Filter out conflicting options for the target question
+      const conflictingForTarget = rule.conflictingOptions[targetQuestion];
+
+      if (conflictingForTarget) {
+        conflictingForTarget.forEach((conflictOption) => {
+          if (filteredOptions[conflictOption]) {
+            delete filteredOptions[conflictOption];
+            appliedFilters.push({
+              removedOption: conflictOption,
+              reason: rule.reason,
+              severity: rule.severity,
+            });
+          }
+        });
+      }
+    }
+  });
+
+  return {
+    filteredOptions,
+    appliedFilters,
+  };
+}
+
+/**
+ * Validate user selection for internal conflicts and return validation message
+ * @param {string} questionType - Question type (documentPurpose, targetAudienceTypes)
+ * @param {Array} selectedValues - User selected values
+ * @returns {string|boolean} Error message if conflicts exist, true if valid
+ */
+export function validateSelection(questionType, selectedValues) {
+  const conflicts = detectInternalConflicts(questionType, selectedValues);
+
+  if (conflicts.length === 0) {
+    return true;
+  }
+
+  // Return error message for severe conflicts
+  const severeConflicts = conflicts.filter((c) => c.severity === "severe");
+  if (severeConflicts.length > 0) {
+    const conflict = severeConflicts[0];
+    return `Conflict detected: ${conflict.reason}. ${conflict.suggestion}`;
+  }
+
+  // For moderate conflicts, allow but warn
+  return true;
+}