@aigne/doc-smith 0.5.1 → 0.7.0

package/tests/preferences-utils.test.mjs

@@ -187,6 +187,100 @@ describe("preferences-utils", () => {
       expect(preferences.rules[0]).toEqual(rule2); // Most recent first
       expect(preferences.rules[1]).toEqual(rule1);
     });
+
+    test("should handle rules with special characters and colons", () => {
+      const ruleData = {
+        rule: 'Always use proper punctuation: semicolons, colons, and quotes"like this"',
+        scope: "document",
+        limitToInputPaths: false,
+      };
+      const feedback = 'Please ensure proper punctuation: don\'t forget quotes"and colons"';
+
+      const newRule = addPreferenceRule(ruleData, feedback);
+
+      expect(newRule.rule).toBe(
+        'Always use proper punctuation: semicolons, colons, and quotes"like this"',
+      );
+      expect(newRule.feedback).toBe(
+        'Please ensure proper punctuation: don\'t forget quotes"and colons"',
+      );
+
+      // Verify it was saved and can be read back
+      const preferences = readPreferences();
+      expect(preferences.rules).toHaveLength(1);
+      expect(preferences.rules[0].rule).toEqual(newRule.rule);
+      expect(preferences.rules[0].feedback).toEqual(newRule.feedback);
+    });
+
+    test("should handle rules with multiline content and special YAML characters", () => {
+      const ruleData = {
+        rule: "Multi-line rule:\\nLine 1: Use proper formatting\\nLine 2: Handle | pipe characters\\nLine 3: And > greater than symbols",
+        scope: "structure",
+        limitToInputPaths: false,
+      };
+      const feedback =
+        "Multi-line feedback:\\n- Check formatting\\n- Validate | pipes\\n- Handle > symbols\\n- Process 'single quotes' and \"double quotes\"";
+
+      const newRule = addPreferenceRule(ruleData, feedback);
+
+      expect(newRule.rule).toContain("Multi-line rule:\\nLine 1");
+      expect(newRule.feedback).toContain("Multi-line feedback:\\n- Check");
+
+      // Verify it was saved and can be read back correctly
+      const preferences = readPreferences();
+      expect(preferences.rules).toHaveLength(1);
+      expect(preferences.rules[0].rule).toEqual(ruleData.rule);
+      expect(preferences.rules[0].feedback).toEqual(feedback);
+    });
+
+    test("should handle rules with Chinese and Unicode characters", () => {
+      const ruleData = {
+        rule: "使用正确的中文标点符号：逗号，句号。还有emoji 🔥 和特殊符号 @#$%^&*()",
+        scope: "document",
+        limitToInputPaths: false,
+      };
+      const feedback = '请确保正确使用标点：引号"这样"和冒号：还有各种符号！@#$%';
+
+      const newRule = addPreferenceRule(ruleData, feedback);
+
+      expect(newRule.rule).toBe(
+        "使用正确的中文标点符号：逗号，句号。还有emoji 🔥 和特殊符号 @#$%^&*()",
+      );
+      expect(newRule.feedback).toBe('请确保正确使用标点：引号"这样"和冒号：还有各种符号！@#$%');
+
+      // Verify it was saved and can be read back
+      const preferences = readPreferences();
+      expect(preferences.rules).toHaveLength(1);
+      expect(preferences.rules[0].rule).toEqual(newRule.rule);
+      expect(preferences.rules[0].feedback).toEqual(newRule.feedback);
+    });
+
+    test("should handle paths with special characters", () => {
+      const ruleData = {
+        rule: "Path-specific rule for special directories",
+        scope: "structure",
+        limitToInputPaths: true,
+      };
+      const feedback = "Apply to special paths only";
+      const paths = [
+        "/docs/api: advanced",
+        "/docs/guide-中文",
+        "/path with spaces",
+        "/symbols@#$%/file",
+      ];
+
+      const newRule = addPreferenceRule(ruleData, feedback, paths);
+
+      expect(newRule.paths).toEqual(paths);
+
+      // Verify it was saved with all special character paths
+      const preferences = readPreferences();
+      expect(preferences.rules[0].paths).toEqual(paths);
+      expect(preferences.rules[0].paths).toContain("/docs/api: advanced");
+      expect(preferences.rules[0].paths).toContain("/docs/guide-中文");
+      expect(preferences.rules[0].paths).toContain("/path with spaces");
+      expect(preferences.rules[0].paths).toContain("/symbols@#$%/file");
+    });
   });
 
   describe("getActiveRulesForScope", () => {

package/tests/save-value-to-config.test.mjs

@@ -59,7 +59,7 @@ describe("saveValueToConfig", () => {
     await saveValueToConfig("projectName", "test-project");
     const content = await readConfigFile();
 
-    expect(content).toContain('projectName: "test-project"');
+    expect(content).toContain("projectName: test-project");
   });
 
   test("Save string value with comment to empty file", async () => {
@@ -67,7 +67,7 @@ describe("saveValueToConfig", () => {
     const content = await readConfigFile();
 
     expect(content).toContain("# Project description");
-    expect(content).toContain('projectDesc: "A test project"');
+    expect(content).toContain("projectDesc: A test project");
   });
 
   test("Save array value to empty file", async () => {
@@ -103,7 +103,7 @@ describe("saveValueToConfig", () => {
     await saveValueToConfig("projectName", "new-project");
     const content = await readConfigFile();
 
-    expect(content).toContain('projectName: "new-project"');
+    expect(content).toContain("projectName: new-project");
     expect(content).toContain('version: "1.0.0"');
     expect(content).not.toContain("old-project");
   });
@@ -160,7 +160,7 @@ version: "1.0.0"`);
     const content = await readConfigFile();
 
     expect(content).toContain("# Updated project name");
-    expect(content).toContain('projectName: "updated-project"');
+    expect(content).toContain("projectName: updated-project");
   });
 
   test("Update value that already has comment", async () => {
@@ -172,7 +172,7 @@ version: "1.0.0"`);
     const content = await readConfigFile();
 
     expect(content).toContain("# Project information");
-    expect(content).toContain('projectName: "new-project"');
+    expect(content).toContain("projectName: new-project");
     expect(content).not.toContain("# Updated project info");
   });
 
@@ -244,4 +244,181 @@ version: "1.0.0"`);
 
     expect(content).toBe(initialContent);
   });
+
+  // Edge cases and special character tests
+  describe("Special characters and edge cases", () => {
+    test("Save string with double quotes", async () => {
+      await saveValueToConfig("projectDesc", 'My "awesome" project with quotes');
+      const content = await readConfigFile();
+
+      // Should be properly escaped
+      expect(content).toContain('My "awesome" project with quotes');
+      // Verify YAML is valid by checking structure
+      expect(content).toContain("projectDesc:");
+    });
+
+    test("Save string with single quotes", async () => {
+      await saveValueToConfig("projectName", "It's a 'great' project");
+      const content = await readConfigFile();
+
+      expect(content).toContain("It's a 'great' project");
+      expect(content).toContain("projectName:");
+    });
+
+    test("Save string with colons and special YAML characters", async () => {
+      await saveValueToConfig(
+        "rule",
+        "Use proper formatting: semicolons; colons: and pipes | symbols",
+      );
+      const content = await readConfigFile();
+
+      expect(content).toContain("Use proper formatting: semicolons; colons: and pipes | symbols");
+      expect(content).toContain("rule:");
+    });
+
+    test("Save multiline string with newlines", async () => {
+      const multilineValue =
+        "Line 1: First line\nLine 2: Second line\nLine 3: Third line with: special characters";
+      await saveValueToConfig("multilineRule", multilineValue);
+      const content = await readConfigFile();
+
+      expect(content).toContain("Line 1: First line");
+      expect(content).toContain("Line 2: Second line");
+      expect(content).toContain("Line 3: Third line with: special characters");
+    });
+
+    test("Save string with Chinese characters and symbols", async () => {
+      await saveValueToConfig(
+        "chineseProject",
+        '中文项目：包含特殊符号！@#￥%…（）—— quotes"and" colons:',
+      );
+      const content = await readConfigFile();
+
+      expect(content).toContain('中文项目：包含特殊符号！@#￥%…（）—— quotes"and" colons:');
+      expect(content).toContain("chineseProject:");
+    });
+
+    test("Save string with emoji and Unicode", async () => {
+      await saveValueToConfig(
+        "emojiProject",
+        "🚀 Project with emoji: 🔥 hot features 💯 and symbols ⭐ ✨ 🎉",
+      );
+      const content = await readConfigFile();
+
+      expect(content).toContain("🚀 Project with emoji: 🔥 hot features 💯 and symbols ⭐ ✨ 🎉");
+      expect(content).toContain("emojiProject:");
+    });
+
+    test("Save array with special character items", async () => {
+      const specialPaths = [
+        "./src: main source",
+        "./lib/utils: helper functions",
+        "./docs-中文/guide",
+        "./path with spaces/file",
+        "./symbols@#$%/directory",
+        './quotes"and"colons:/path',
+      ];
+      await saveValueToConfig("specialPaths", specialPaths);
+      const content = await readConfigFile();
+
+      expect(content).toContain("specialPaths:");
+      specialPaths.forEach((path) => {
+        expect(content).toContain(path);
+      });
+    });
+
+    test("Save array with multiline items", async () => {
+      const multilineArray = [
+        "Item 1:\nWith newline content",
+        "Item 2: Simple item",
+        "Item 3:\nMultiple\nLines\nWith: colons and | pipes",
+      ];
+      await saveValueToConfig("multilineArray", multilineArray);
+      const content = await readConfigFile();
+
+      expect(content).toContain("multilineArray:");
+      expect(content).toContain("Item 1:");
+      expect(content).toContain("With newline content");
+      expect(content).toContain("Item 3:");
+      expect(content).toContain("With: colons and | pipes");
+    });
+
+    test("Update existing value containing special characters", async () => {
+      await createInitialConfig('projectName: "old: project with | pipes"\nversion: "1.0.0"');
+
+      await saveValueToConfig("projectName", 'new: project with "quotes" and | pipes: updated');
+      const content = await readConfigFile();
+
+      expect(content).toContain('new: project with "quotes" and | pipes: updated');
+      expect(content).toContain('version: "1.0.0"');
+      expect(content).not.toContain("old: project");
+    });
+
+    test("Save very long string with special characters", async () => {
+      const longString =
+        "A very long project description that contains many special characters: colons, semicolons; quotes \"like this\", single quotes 'like this', pipes | symbols, Chinese characters 中文内容：包含各种符号！@#￥%…（）——, emojis 🚀🔥💯⭐✨🎉, and newlines\nSecond line with more content\nThird line: even more special content with all sorts of symbols @#$%^&*()_+-=[]{}|\\;':./?,<>~`";
+      await saveValueToConfig("veryLongDesc", longString);
+      const content = await readConfigFile();
+
+      expect(content).toContain("veryLongDesc:");
+      expect(content).toContain("A very long project description");
+      expect(content).toContain("中文内容：包含各种符号");
+      expect(content).toContain("🚀🔥💯⭐✨🎉");
+      expect(content).toContain("Second line with more content");
+    });
+
+    test("Save empty string", async () => {
+      await saveValueToConfig("emptyString", "");
+      const content = await readConfigFile();
+
+      expect(content).toContain('emptyString: ""');
+    });
+
+    test("Save string that looks like YAML syntax", async () => {
+      await saveValueToConfig("yamlLikeString", "key: value\nother: - item1\n- item2: subvalue");
+      const content = await readConfigFile();
+
+      expect(content).toContain("yamlLikeString:");
+      expect(content).toContain("key: value");
+      expect(content).toContain("other: - item1");
+      expect(content).toContain("- item2: subvalue");
+    });
+
+    test("Complex mixed scenario with multiple special character values", async () => {
+      // Create initial config with some special content
+      await createInitialConfig(`# Project configuration
+# with special comments: and symbols
+projectName: "original: project"
+locale: zh`);
+
+      // Update with various special character content
+      await saveValueToConfig("projectDesc", 'Updated description: with "quotes" and | pipes');
+      await saveValueToConfig("specialArray", [
+        "path: with colons",
+        "中文路径/文件",
+        "emoji 🔥 path",
+      ]);
+      await saveValueToConfig(
+        "multilineContent",
+        "Line 1: content\nLine 2: more content\nLine 3: final content",
+      );
+
+      const content = await readConfigFile();
+
+      // Check all content is preserved
+      expect(content).toContain("# Project configuration");
+      expect(content).toContain("# with special comments: and symbols");
+      expect(content).toContain('projectName: "original: project"');
+      expect(content).toContain("locale: zh");
+      expect(content).toContain('Updated description: with "quotes" and | pipes');
+      expect(content).toContain("specialArray:");
+      expect(content).toContain("path: with colons");
+      expect(content).toContain("中文路径/文件");
+      expect(content).toContain("emoji 🔥 path");
+      expect(content).toContain("multilineContent:");
+      expect(content).toContain("Line 1: content");
+      expect(content).toContain("Line 2: more content");
+      expect(content).toContain("Line 3: final content");
+    });
+  });
 });

package/tests/utils.test.mjs

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { isGlobPattern } from "../utils/utils.mjs";
+
+describe("utils", () => {
+  describe("isGlobPattern", () => {
+    test("should return true for patterns with asterisk", () => {
+      expect(isGlobPattern("*.js")).toBe(true);
+      expect(isGlobPattern("src/*.js")).toBe(true);
+      expect(isGlobPattern("**/*.js")).toBe(true);
+      expect(isGlobPattern("src/**/*.js")).toBe(true);
+    });
+
+    test("should return true for patterns with question mark", () => {
+      expect(isGlobPattern("file?.js")).toBe(true);
+      expect(isGlobPattern("src/?odal.js")).toBe(true);
+    });
+
+    test("should return true for patterns with character classes", () => {
+      expect(isGlobPattern("file[abc].js")).toBe(true);
+      expect(isGlobPattern("src/[Bb]utton.js")).toBe(true);
+      expect(isGlobPattern("file[0-9].js")).toBe(true);
+    });
+
+    test("should return true for patterns with double asterisk", () => {
+      expect(isGlobPattern("**/file.js")).toBe(true);
+      expect(isGlobPattern("src/**/file.js")).toBe(true);
+    });
+
+    test("should return false for regular paths", () => {
+      expect(isGlobPattern("src/file.js")).toBe(false);
+      expect(isGlobPattern("./src")).toBe(false);
+      expect(isGlobPattern("/absolute/path")).toBe(false);
+      expect(isGlobPattern("regular-file.js")).toBe(false);
+      expect(isGlobPattern("package.json")).toBe(false);
+    });
+
+    test("should return false for empty or undefined input", () => {
+      expect(isGlobPattern("")).toBe(false);
+      expect(isGlobPattern(undefined)).toBe(false);
+      expect(isGlobPattern(null)).toBe(false);
+    });
+
+    test("should handle complex patterns", () => {
+      expect(isGlobPattern("src/**/*.{js,ts,jsx,tsx}")).toBe(true);
+      expect(isGlobPattern("components/**/[A-Z]*.js")).toBe(true);
+      expect(isGlobPattern("test/**/*test.js")).toBe(true);
+    });
+  });
+});

package/utils/auth-utils.mjs

@@ -91,7 +91,7 @@ export async function getAccessToken(appUrl) {
       source: `AIGNE DocSmith connect to Discuss Kit`,
       closeOnSuccess: true,
       appName: "AIGNE DocSmith",
-      appLogo: "https://www.aigne.io/image-bin/uploads/a7910a71364ee15a27e86f869ad59009.svg",
+      appLogo: "https://docsmith.aigne.io/image-bin/uploads/a7910a71364ee15a27e86f869ad59009.svg",
       openPage: (pageUrl) => open(pageUrl),
     });
 

package/utils/conflict-detector.mjs

@@ -1,4 +1,4 @@
-import { CONFLICT_RULES } from "./constants.mjs";
+import { CONFLICT_RESOLUTION_RULES, CONFLICT_RULES, RESOLUTION_STRATEGIES } from "./constants.mjs";
 
 /**
  * Detect internal conflicts within the same question (multi-select conflicts)
@@ -129,3 +129,74 @@ export function validateSelection(questionType, selectedValues) {
   // For moderate conflicts, allow but warn
   return true;
 }
+
+/**
+ * Detect conflicts in user configuration selections that can be resolved through structure planning
+ * @param {Object} config - User configuration
+ * @returns {Array} Array of detected conflicts with resolution strategies
+ */
+export function detectResolvableConflicts(config) {
+  const conflicts = [];
+
+  // Check each question type for conflicts
+  Object.entries(CONFLICT_RESOLUTION_RULES).forEach(([questionType, rules]) => {
+    const selectedValues = config[questionType];
+
+    if (!selectedValues || !Array.isArray(selectedValues) || selectedValues.length < 2) {
+      return; // Skip if not multi-select or less than 2 items
+    }
+
+    // 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,
+    );
+
+    // Check each conflict rule
+    rules.forEach((rule) => {
+      // Check if all conflict items are selected
+      const hasConflict = rule.conflictItems.every((item) => selectedValueStrings.includes(item));
+
+      if (hasConflict) {
+        conflicts.push({
+          type: questionType,
+          items: rule.conflictItems,
+          strategy: rule.strategy,
+          description: rule.description,
+        });
+      }
+    });
+  });
+
+  return conflicts;
+}
+
+/**
+ * Generate conflict resolution rules based on detected conflicts
+ * @param {Array} conflicts - Array of detected conflicts
+ * @returns {string} Conflict resolution instructions
+ */
+export function generateConflictResolutionRules(conflicts) {
+  if (conflicts.length === 0) return "";
+
+  const rules = ["=== Conflict Resolution Guidelines ==="];
+
+  conflicts.forEach((conflict) => {
+    const strategy = RESOLUTION_STRATEGIES[conflict.strategy];
+    if (strategy) {
+      rules.push(strategy(conflict.items));
+    }
+  });
+
+  rules.push("");
+  rules.push("Conflict Resolution Principles:");
+  rules.push(
+    "1. Meet diverse needs through intelligent structural design, not simple concatenation",
+  );
+  rules.push("2. Create clear navigation paths for different purposes and audiences");
+  rules.push(
+    "3. Ensure content hierarchy is reasonable, avoid information duplication or contradiction",
+  );
+  rules.push("4. Prioritize user experience, enable users to quickly find needed information");
+
+  return rules.join("\n");
+}