@aigne/doc-smith 0.7.2 → 0.8.0

package/tests/utils.test.mjs

@@ -1,7 +1,323 @@
-import { describe, expect, test } from "bun:test";
-import { isGlobPattern } from "../utils/utils.mjs";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  detectSystemLanguage,
+  getAvailablePaths,
+  getContentHash,
+  getCurrentGitHead,
+  getGitHubRepoInfo,
+  getGithubRepoUrl,
+  getModifiedFilesBetweenCommits,
+  getProjectInfo,
+  hasFileChangesBetweenCommits,
+  hasSourceFilesChanged,
+  isGlobPattern,
+  loadConfigFromFile,
+  normalizePath,
+  processConfigFields,
+  processContent,
+  resolveFileReferences,
+  saveDocWithTranslations,
+  saveGitHeadToConfig,
+  saveValueToConfig,
+  toRelativePath,
+  validatePath,
+  validatePaths,
+} from "../utils/utils.mjs";
 
 describe("utils", () => {
+  let tempDir;
+
+  beforeEach(() => {
+    tempDir = path.join(os.tmpdir(), `utils-test-${Date.now()}`);
+    if (!existsSync(tempDir)) {
+      mkdirSync(tempDir, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("normalizePath", () => {
+    test("should return absolute path when given absolute path", () => {
+      const absolutePath = "/usr/local/bin";
+      expect(normalizePath(absolutePath)).toBe(absolutePath);
+    });
+
+    test("should resolve relative path to absolute path", () => {
+      const relativePath = "./test";
+      const result = normalizePath(relativePath);
+      expect(path.isAbsolute(result)).toBe(true);
+      expect(result).toContain("test");
+    });
+
+    test("should handle empty string", () => {
+      const result = normalizePath("");
+      expect(path.isAbsolute(result)).toBe(true);
+    });
+  });
+
+  describe("toRelativePath", () => {
+    test("should convert absolute path to relative", () => {
+      const absolutePath = path.join(process.cwd(), "test", "file.js");
+      const result = toRelativePath(absolutePath);
+      expect(result).toBe(path.join("test", "file.js"));
+    });
+
+    test("should return relative path unchanged", () => {
+      const relativePath = "./test/file.js";
+      expect(toRelativePath(relativePath)).toBe(relativePath);
+    });
+
+    test("should handle current working directory", () => {
+      const result = toRelativePath(process.cwd());
+      expect(result).toBe("");
+    });
+  });
+
+  describe("processContent", () => {
+    test("should process markdown links correctly", () => {
+      const content = "Check out [this link](./docs/readme) for more info.";
+      const result = processContent({ content });
+      expect(result).toBe("Check out [this link](./docs-readme.md) for more info.");
+    });
+
+    test("should preserve external links", () => {
+      const content = "Visit [Google](https://google.com) for search.";
+      const result = processContent({ content });
+      expect(result).toBe(content);
+    });
+
+    test("should preserve mailto links", () => {
+      const content = "Contact [us](mailto:test@example.com).";
+      const result = processContent({ content });
+      expect(result).toBe(content);
+    });
+
+    test("should handle links with anchors", () => {
+      const content = "See [section](./guide#installation) for details.";
+      const result = processContent({ content });
+      expect(result).toBe("See [section](./guide.md#installation) for details.");
+    });
+
+    test("should not process image links", () => {
+      const content = "Here's an image: ![alt text](./image.png)";
+      const result = processContent({ content });
+      expect(result).toBe(content);
+    });
+
+    test("should handle links with existing extensions", () => {
+      const content = "Download [file](./docs/readme.pdf) here.";
+      const result = processContent({ content });
+      expect(result).toBe(content);
+    });
+
+    test("should handle root-relative paths", () => {
+      const content = "Check [root link](/docs/api) here.";
+      const result = processContent({ content });
+      expect(result).toBe("Check [root link](./docs-api.md) here.");
+    });
+
+    test("should handle paths starting with dot", () => {
+      const content = "See [dotted path](./src/utils) for more.";
+      const result = processContent({ content });
+      expect(result).toBe("See [dotted path](./src-utils.md) for more.");
+    });
+  });
+
+  describe("getContentHash", () => {
+    test("should return consistent hash for same content", () => {
+      const content = "test content";
+      const hash1 = getContentHash(content);
+      const hash2 = getContentHash(content);
+      expect(hash1).toBe(hash2);
+    });
+
+    test("should return different hashes for different content", () => {
+      const content1 = "test content 1";
+      const content2 = "test content 2";
+      const hash1 = getContentHash(content1);
+      const hash2 = getContentHash(content2);
+      expect(hash1).not.toBe(hash2);
+    });
+
+    test("should return 64-character hex string", () => {
+      const content = "test";
+      const hash = getContentHash(content);
+      expect(hash).toMatch(/^[a-f0-9]{64}$/);
+    });
+
+    test("should handle empty string", () => {
+      const hash = getContentHash("");
+      expect(hash).toMatch(/^[a-f0-9]{64}$/);
+    });
+  });
+
+  describe("validatePath", () => {
+    test("should validate existing file", () => {
+      const testFile = path.join(tempDir, "test.txt");
+      writeFileSync(testFile, "test content");
+
+      const result = validatePath(testFile);
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBe(null);
+    });
+
+    test("should validate existing directory", () => {
+      const result = validatePath(tempDir);
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBe(null);
+    });
+
+    test("should invalidate non-existent path", () => {
+      const nonExistentPath = path.join(tempDir, "non-existent");
+      const result = validatePath(nonExistentPath);
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain("does not exist");
+    });
+
+    test("should handle relative paths", () => {
+      const testFile = path.join(tempDir, "relative-test.txt");
+      writeFileSync(testFile, "content");
+
+      const relativePath = path.relative(process.cwd(), testFile);
+      const result = validatePath(relativePath);
+      expect(result.isValid).toBe(true);
+    });
+  });
+
+  describe("validatePaths", () => {
+    test("should validate multiple valid paths", () => {
+      const testFile1 = path.join(tempDir, "test1.txt");
+      const testFile2 = path.join(tempDir, "test2.txt");
+      writeFileSync(testFile1, "content1");
+      writeFileSync(testFile2, "content2");
+
+      const result = validatePaths([testFile1, testFile2]);
+      expect(result.validPaths).toHaveLength(2);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    test("should separate valid and invalid paths", () => {
+      const testFile = path.join(tempDir, "valid.txt");
+      const invalidFile = path.join(tempDir, "invalid.txt");
+      writeFileSync(testFile, "content");
+
+      const result = validatePaths([testFile, invalidFile]);
+      expect(result.validPaths).toHaveLength(1);
+      expect(result.errors).toHaveLength(1);
+      expect(result.validPaths[0]).toBe(testFile);
+      expect(result.errors[0].path).toBe(invalidFile);
+    });
+
+    test("should handle empty array", () => {
+      const result = validatePaths([]);
+      expect(result.validPaths).toHaveLength(0);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe("detectSystemLanguage", () => {
+    test("should return a valid language code", () => {
+      const result = detectSystemLanguage();
+      expect(typeof result).toBe("string");
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    test("should return 'en' as default when no env vars", () => {
+      const originalEnv = {
+        LANG: process.env.LANG,
+        LANGUAGE: process.env.LANGUAGE,
+        LC_ALL: process.env.LC_ALL,
+      };
+
+      delete process.env.LANG;
+      delete process.env.LANGUAGE;
+      delete process.env.LC_ALL;
+
+      const result = detectSystemLanguage();
+
+      // Restore original env vars
+      if (originalEnv.LANG) process.env.LANG = originalEnv.LANG;
+      if (originalEnv.LANGUAGE) process.env.LANGUAGE = originalEnv.LANGUAGE;
+      if (originalEnv.LC_ALL) process.env.LC_ALL = originalEnv.LC_ALL;
+
+      expect(result).toBe("en");
+    });
+
+    test("should handle Chinese locale variants", () => {
+      const originalLang = process.env.LANG;
+
+      process.env.LANG = "zh_TW.UTF-8";
+      let result = detectSystemLanguage();
+      expect(result).toBe("zh"); // "zh" is found first in SUPPORTED_LANGUAGES
+
+      process.env.LANG = "zh_CN.UTF-8";
+      result = detectSystemLanguage();
+      expect(result).toBe("zh");
+
+      if (originalLang) {
+        process.env.LANG = originalLang;
+      } else {
+        delete process.env.LANG;
+      }
+    });
+
+    test("detectSystemLanguage should handle edge cases", () => {
+      const originalEnv = {
+        LANG: process.env.LANG,
+        LANGUAGE: process.env.LANGUAGE,
+        LC_ALL: process.env.LC_ALL,
+      };
+
+      // Test case 1: No system locale at all
+      delete process.env.LANG;
+      delete process.env.LANGUAGE;
+      delete process.env.LC_ALL;
+
+      // Mock Intl to also fail
+      const originalDateTimeFormat = Intl.DateTimeFormat;
+      Intl.DateTimeFormat = () => {
+        throw new Error("Intl not available");
+      };
+
+      try {
+        const result = detectSystemLanguage();
+        expect(result).toBe("en"); // Should fall back to default
+      } finally {
+        Intl.DateTimeFormat = originalDateTimeFormat;
+      }
+
+      // Test case 2: Handle special Chinese locale variants
+      process.env.LANG = "zh_TW";
+      let result = detectSystemLanguage();
+      expect(["zh", "zh-TW"].includes(result)).toBe(true);
+
+      process.env.LANG = "zh_HK.Big5";
+      result = detectSystemLanguage();
+      expect(["zh", "zh-TW"].includes(result)).toBe(true);
+
+      // Test case 3: Unsupported language
+      process.env.LANG = "xx_XX.UTF-8"; // Non-existent language
+      result = detectSystemLanguage();
+      expect(result).toBe("en"); // Should fall back to default
+
+      // Restore original environment
+      if (originalEnv.LANG) process.env.LANG = originalEnv.LANG;
+      else delete process.env.LANG;
+      if (originalEnv.LANGUAGE) process.env.LANGUAGE = originalEnv.LANGUAGE;
+      else delete process.env.LANGUAGE;
+      if (originalEnv.LC_ALL) process.env.LC_ALL = originalEnv.LC_ALL;
+      else delete process.env.LC_ALL;
+    });
+  });
+
   describe("isGlobPattern", () => {
     test("should return true for patterns with asterisk", () => {
       expect(isGlobPattern("*.js")).toBe(true);
@@ -46,4 +362,1706 @@ describe("utils", () => {
       expect(isGlobPattern("test/**/*test.js")).toBe(true);
     });
   });
+
+  describe("saveDocWithTranslations", () => {
+    test("should save document without translations", async () => {
+      const docsDir = path.join(tempDir, "docs");
+      const result = await saveDocWithTranslations({
+        path: "test-doc",
+        content: "# Test Document\n\nContent here.",
+        docsDir,
+        locale: "en",
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result[0].success).toBe(true);
+      expect(existsSync(path.join(docsDir, "test-doc.md"))).toBe(true);
+    });
+
+    test("should save document with translations", async () => {
+      const docsDir = path.join(tempDir, "docs");
+      const result = await saveDocWithTranslations({
+        path: "test-doc",
+        content: "# Test Document",
+        docsDir,
+        locale: "en",
+        translates: [{ language: "zh", translation: "# 测试文档" }],
+      });
+
+      expect(result).toHaveLength(2);
+      expect(result.every((r) => r.success)).toBe(true);
+      expect(existsSync(path.join(docsDir, "test-doc.md"))).toBe(true);
+      expect(existsSync(path.join(docsDir, "test-doc.zh.md"))).toBe(true);
+    });
+
+    test("should handle path with slashes", async () => {
+      const docsDir = path.join(tempDir, "docs");
+      const result = await saveDocWithTranslations({
+        path: "/api/user",
+        content: "# API Documentation",
+        docsDir,
+        locale: "en",
+      });
+
+      expect(result[0].success).toBe(true);
+      expect(existsSync(path.join(docsDir, "api-user.md"))).toBe(true);
+    });
+
+    test("should add labels to front matter", async () => {
+      const docsDir = path.join(tempDir, "docs");
+      await saveDocWithTranslations({
+        path: "labeled-doc",
+        content: "# Test",
+        docsDir,
+        locale: "en",
+        labels: ["api", "guide"],
+      });
+
+      const content = readFileSync(path.join(docsDir, "labeled-doc.md"), "utf8");
+      expect(content).toContain('labels: ["api","guide"]');
+    });
+
+    test("should skip main content when isTranslate is true", async () => {
+      const docsDir = path.join(tempDir, "docs");
+      const result = await saveDocWithTranslations({
+        path: "translate-only",
+        content: "# Main",
+        docsDir,
+        locale: "en",
+        translates: [{ language: "zh", translation: "# 中文" }],
+        isTranslate: true,
+      });
+
+      expect(result).toHaveLength(1);
+      expect(existsSync(path.join(docsDir, "translate-only.md"))).toBe(false);
+      expect(existsSync(path.join(docsDir, "translate-only.zh.md"))).toBe(true);
+    });
+  });
+
+  describe("getCurrentGitHead", () => {
+    test("should return current git HEAD hash in real git repository", () => {
+      const result = getCurrentGitHead();
+      // In our real git repository, should return a valid hash
+      expect(typeof result).toBe("string");
+      expect(result.length).toBe(40); // Git SHA-1 hash length
+      expect(result).toMatch(/^[a-f0-9]{40}$/); // Valid hex hash
+    });
+
+    test("should handle git command errors gracefully", () => {
+      // Mock console.warn to capture warning messages
+      const originalWarn = console.warn;
+      const warnMessages = [];
+      console.warn = (message) => warnMessages.push(message);
+
+      // Change to a non-git directory temporarily
+      const originalCwd = process.cwd();
+      const nonGitDir = path.join(tempDir, "non-git");
+      mkdirSync(nonGitDir, { recursive: true });
+
+      try {
+        process.chdir(nonGitDir);
+        const result = getCurrentGitHead();
+        expect(result).toBe(null);
+        // Should have logged a warning
+        expect(warnMessages.some((msg) => msg.includes("Failed to get git HEAD:"))).toBe(true);
+      } finally {
+        process.chdir(originalCwd);
+        console.warn = originalWarn;
+      }
+    });
+  });
+
+  describe("getModifiedFilesBetweenCommits", () => {
+    test("should return modified files between recent commits", () => {
+      // Dynamically get the last few commits to avoid hardcoded commit issues
+      const currentHead = getCurrentGitHead();
+      if (!currentHead) {
+        // Skip test if not in a git repository
+        return;
+      }
+
+      // Try to get the previous commit (HEAD~1)
+      let previousCommit;
+      try {
+        previousCommit = execSync("git rev-parse HEAD~1", {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+      } catch {
+        // If there's no previous commit, skip this test
+        return;
+      }
+
+      const result = getModifiedFilesBetweenCommits(previousCommit, currentHead);
+      expect(Array.isArray(result)).toBe(true);
+
+      // Validate file format if any files are returned
+      result.forEach((file) => {
+        expect(typeof file).toBe("string");
+        expect(file.length).toBeGreaterThan(0);
+      });
+    });
+
+    test("should detect changes between commits with more history", () => {
+      // Try to find commits that are further apart by checking if we have enough history
+      let olderCommit;
+      try {
+        olderCommit = execSync("git rev-parse HEAD~3", {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+      } catch {
+        // If we don't have enough history, skip this test
+        return;
+      }
+
+      const result = getModifiedFilesBetweenCommits(olderCommit, "HEAD");
+      expect(Array.isArray(result)).toBe(true);
+      // With 3+ commits difference, there should usually be some changes
+      // But we won't enforce this since it depends on the actual history
+    });
+
+    test("should filter by provided file paths when files exist in changes", () => {
+      // First try to get some modified files
+      let olderCommit;
+      try {
+        olderCommit = execSync("git rev-parse HEAD~2", {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+      } catch {
+        return; // Skip if not enough history
+      }
+
+      const allModified = getModifiedFilesBetweenCommits(olderCommit, "HEAD");
+
+      if (allModified.length > 0) {
+        // Test filtering with actual modified file
+        const testFile = allModified[0];
+        const result = getModifiedFilesBetweenCommits(olderCommit, "HEAD", [testFile]);
+        expect(Array.isArray(result)).toBe(true);
+        expect(result).toContain(testFile);
+      }
+    });
+
+    test("should return empty array for same commit", () => {
+      const result = getModifiedFilesBetweenCommits("HEAD", "HEAD");
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(0);
+    });
+
+    test("should handle invalid commits gracefully", () => {
+      const result = getModifiedFilesBetweenCommits("invalid-commit1", "invalid-commit2");
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(0); // Should return empty array for invalid commits
+    });
+  });
+
+  describe("hasSourceFilesChanged", () => {
+    test("should return false for empty inputs", () => {
+      expect(hasSourceFilesChanged([], [])).toBe(false);
+      expect(hasSourceFilesChanged(null, [])).toBe(false);
+      expect(hasSourceFilesChanged(["test.js"], null)).toBe(false);
+    });
+
+    test("should detect changes when files match", () => {
+      const sourceIds = ["/path/to/file.js"];
+      const modifiedFiles = ["/path/to/file.js"];
+      expect(hasSourceFilesChanged(sourceIds, modifiedFiles)).toBe(true);
+    });
+
+    test("should return false when no files match", () => {
+      const sourceIds = ["/path/to/file1.js"];
+      const modifiedFiles = ["/path/to/file2.js"];
+      expect(hasSourceFilesChanged(sourceIds, modifiedFiles)).toBe(false);
+    });
+  });
+
+  describe("hasFileChangesBetweenCommits", () => {
+    test("should detect file additions/deletions with dynamic commits", () => {
+      // hasFileChangesBetweenCommits only checks for added (A) and deleted (D) files, not modified (M) files
+      // It also excludes test files by default since they don't affect documentation structure
+
+      // Try to get commits dynamically
+      let olderCommit;
+      try {
+        olderCommit = execSync("git rev-parse HEAD~3", {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+      } catch {
+        // If we don't have enough history, skip this test
+        return;
+      }
+
+      const result = hasFileChangesBetweenCommits(olderCommit, "HEAD");
+      expect(typeof result).toBe("boolean");
+
+      // The result depends on actual git history, so we just verify it's a boolean
+      // In most cases with test files being excluded, it might be false
+    });
+
+    test("should detect changes when exclude patterns are empty", () => {
+      // Test with empty exclude patterns to verify detection mechanism works
+      let olderCommit;
+      try {
+        olderCommit = execSync("git rev-parse HEAD~2", {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+      } catch {
+        return; // Skip if not enough history
+      }
+
+      const result = hasFileChangesBetweenCommits(olderCommit, "HEAD", ["*.mjs", "*.js"], []);
+      expect(typeof result).toBe("boolean");
+
+      // With no exclusions and broad include patterns, more likely to detect changes
+    });
+
+    test("should return false for same commit", () => {
+      const result = hasFileChangesBetweenCommits("HEAD", "HEAD");
+      expect(result).toBe(false);
+    });
+
+    test("should respect include patterns for JavaScript files", () => {
+      // Try with recent commits
+      let olderCommit;
+      try {
+        olderCommit = execSync("git rev-parse HEAD~1", {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+      } catch {
+        return;
+      }
+
+      const result = hasFileChangesBetweenCommits(
+        olderCommit,
+        "HEAD",
+        ["*.js", "*.mjs", "*.ts"], // Include JS-related files
+        [],
+      );
+      expect(typeof result).toBe("boolean");
+    });
+
+    test("should respect exclude patterns", () => {
+      // Test excluding test files but including other JS files
+      let olderCommit;
+      try {
+        olderCommit = execSync("git rev-parse HEAD~2", {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+      } catch {
+        return;
+      }
+
+      const result = hasFileChangesBetweenCommits(
+        olderCommit,
+        "HEAD",
+        ["*.mjs"], // Include mjs files
+        ["tests/**"], // But exclude test directory
+      );
+      expect(typeof result).toBe("boolean");
+    });
+
+    test("should handle complex include/exclude pattern combinations", () => {
+      // Test with a broader range if available
+      let olderCommit;
+      try {
+        olderCommit = execSync("git rev-parse HEAD~4", {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+      } catch {
+        return;
+      }
+
+      const result = hasFileChangesBetweenCommits(
+        olderCommit,
+        "HEAD",
+        ["*.mjs", "*.js"], // Include JS files
+        ["node_modules/**", "dist/**"], // Exclude build artifacts
+      );
+      expect(typeof result).toBe("boolean");
+    });
+
+    test("should return false for invalid commits", () => {
+      const result = hasFileChangesBetweenCommits("invalid-commit1", "invalid-commit2");
+      expect(result).toBe(false);
+    });
+
+    test("should handle commits with no matching file patterns", () => {
+      let olderCommit;
+      try {
+        olderCommit = execSync("git rev-parse HEAD~1", {
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "ignore"],
+        }).trim();
+      } catch {
+        return;
+      }
+
+      const result = hasFileChangesBetweenCommits(
+        olderCommit,
+        "HEAD",
+        ["*.nonexistent"], // Pattern that won't match any files
+        [],
+      );
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("getAvailablePaths", () => {
+    beforeEach(() => {
+      // Create a complex directory structure for testing
+      const testStructure = {
+        src: {
+          components: {
+            "Button.js": "export default Button",
+            "Modal.js": "export default Modal",
+          },
+          utils: {
+            "helpers.js": "export const help = () => {}",
+            "constants.js": "export const API_URL = 'test'",
+          },
+          "index.js": "export * from './components'",
+        },
+        tests: {
+          unit: {
+            "button.test.js": "test('button', () => {})",
+          },
+          integration: {
+            "app.test.js": "test('app', () => {})",
+          },
+        },
+        docs: {
+          "README.md": "# Documentation",
+          "api.md": "# API Reference",
+        },
+        "package.json": '{"name": "test-project"}',
+        "config.yaml": "test: true",
+        ".gitignore": "node_modules/",
+      };
+
+      createDirectoryStructure(tempDir, testStructure);
+    });
+
+    test("should return current directory contents when no input", () => {
+      // Mock process.cwd to return tempDir for this test
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      const result = getAvailablePaths();
+
+      process.cwd = originalCwd;
+
+      expect(Array.isArray(result)).toBe(true);
+
+      // We created 5 items: src, tests, docs, package.json, config.yaml, .gitignore
+      // But .gitignore should be filtered out (hidden file)
+      expect(result.length).toBe(5);
+
+      // Should have required properties
+      result.forEach((item) => {
+        expect(item).toHaveProperty("name");
+        expect(item).toHaveProperty("value");
+        expect(item).toHaveProperty("description");
+        expect(typeof item.name).toBe("string");
+        expect(typeof item.value).toBe("string");
+        expect(typeof item.description).toBe("string");
+      });
+
+      // Should find our test directories and files (with ./ prefix)
+      const names = result.map((r) => r.name);
+      expect(names).toContain("./src");
+      expect(names).toContain("./tests");
+      expect(names).toContain("./docs");
+      expect(names).toContain("./package.json");
+      expect(names).toContain("./config.yaml");
+
+      // Should not contain hidden files
+      expect(names.find((name) => name.includes(".gitignore"))).toBeUndefined();
+    });
+
+    test("should filter by search term correctly", () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      // Search for items containing "src"
+      const result = getAvailablePaths("src");
+
+      process.cwd = originalCwd;
+
+      expect(Array.isArray(result)).toBe(true);
+
+      expect(result.length).toBe(1);
+      expect(result[0].description).toBe("📁 Directory");
+
+      expect(result[0].name).toBe("src");
+
+      process.cwd = () => tempDir;
+      const packResult = getAvailablePaths("pack");
+      process.cwd = originalCwd;
+
+      expect(packResult.length).toBe(1);
+      expect(packResult[0].name).toBe("./package.json");
+      expect(packResult[0].description).toBe("📄 File");
+    });
+
+    test("Should not return duplicate paths for the same file/directory", () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      // This test demonstrates the duplication bug
+      const result = getAvailablePaths("src");
+
+      process.cwd = originalCwd;
+
+      // Extract all unique actual paths (normalize both "src" and "./src" to the same absolute path)
+      const absolutePaths = result.map((r) => path.resolve(tempDir, r.name));
+      const uniqueAbsolutePaths = [...new Set(absolutePaths)];
+
+      expect(result.length).toBe(uniqueAbsolutePaths.length); // Should be equal (no duplicates)
+
+      // Additional check: No two results should point to the same physical path
+      expect(absolutePaths.length).toBe(uniqueAbsolutePaths.length);
+    });
+
+    test("should handle absolute path navigation", () => {
+      const srcPath = path.join(tempDir, "src");
+      const result = getAvailablePaths(srcPath);
+
+      expect(Array.isArray(result)).toBe(true);
+      // Should find exactly the src directory itself (as it's navigating TO the src path)
+      expect(result.length).toBe(1);
+      expect(result[0].name).toBe(srcPath);
+      expect(result[0].value).toBe(srcPath);
+      expect(result[0].description).toBe("📁 Directory");
+    });
+
+    test("should handle relative path with ./ prefix", () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      const result = getAvailablePaths("./src");
+
+      process.cwd = originalCwd;
+
+      expect(Array.isArray(result)).toBe(true);
+      // Should find exactly the src directory (matching exact path)
+      expect(result.length).toBe(1);
+      expect(result[0].name).toBe("./src");
+      expect(result[0].description).toBe("📁 Directory");
+    });
+
+    test("should handle nested path navigation", () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      const result = getAvailablePaths("./src/comp");
+
+      process.cwd = originalCwd;
+
+      expect(Array.isArray(result)).toBe(true);
+      // Should find exactly the components directory that matches "comp"
+      expect(result.length).toBe(1);
+      expect(result[0].name).toBe("./src/components");
+      expect(result[0].description).toBe("📁 Directory");
+    });
+
+    test("should distinguish between files and directories", () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      const result = getAvailablePaths();
+
+      process.cwd = originalCwd;
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(5);
+
+      // Should have exactly 3 directories and 2 files
+      const directories = result.filter((r) => r.description === "📁 Directory");
+      const files = result.filter((r) => r.description === "📄 File");
+
+      expect(directories.length).toBe(3); // src, tests, docs
+      expect(files.length).toBe(2); // package.json, config.yaml
+
+      // Verify specific items
+      const srcItem = result.find((r) => r.name === "./src");
+      expect(srcItem.description).toBe("📁 Directory");
+
+      const packageItem = result.find((r) => r.name === "./package.json");
+      expect(packageItem.description).toBe("📄 File");
+
+      const configItem = result.find((r) => r.name === "./config.yaml");
+      expect(configItem.description).toBe("📄 File");
+    });
+
+    test("should handle non-existent directory gracefully", () => {
+      const result = getAvailablePaths("/non/existent/path");
+
+      expect(Array.isArray(result)).toBe(true);
+      // Should return exactly 1 error item
+      expect(result.length).toBe(1);
+      expect(result[0]).toHaveProperty("description");
+      expect(result[0].description).toContain("does not exist");
+      expect(result[0].name).toBe("/non/existent");
+      expect(result[0].value).toBe("/non/existent");
+    });
+
+    test("should exclude common ignore patterns", () => {
+      // Create additional test structure with ignored items
+      const ignoredStructure = {
+        node_modules: {
+          package: "ignored",
+        },
+        ".git": {
+          config: "ignored",
+        },
+        dist: {
+          "bundle.js": "ignored",
+        },
+      };
+
+      createDirectoryStructure(tempDir, ignoredStructure);
+
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      const result = getAvailablePaths();
+
+      process.cwd = originalCwd;
+
+      expect(Array.isArray(result)).toBe(true);
+      // Should still be 5 items (original ones), ignored items should be filtered out
+      expect(result.length).toBe(5);
+
+      // Should not include ignored patterns
+      const names = result.map((r) => r.name);
+      expect(names).not.toContain("./node_modules");
+      expect(names).not.toContain("./.git");
+      expect(names).not.toContain("./dist");
+      expect(names).not.toContain("./build");
+
+      // Should still contain the original items
+      expect(names).toContain("./src");
+      expect(names).toContain("./tests");
+      expect(names).toContain("./docs");
+    });
+
+    test("should sort results alphabetically with directories first", () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      const result = getAvailablePaths();
+
+      process.cwd = originalCwd;
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(5);
+
+      // Expected order: directories first (docs, src, tests), then files (config.yaml, package.json)
+      expect(result[0].name).toBe("./docs");
+      expect(result[0].description).toBe("📁 Directory");
+
+      expect(result[1].name).toBe("./src");
+      expect(result[1].description).toBe("📁 Directory");
+
+      expect(result[2].name).toBe("./tests");
+      expect(result[2].description).toBe("📁 Directory");
+
+      expect(result[3].name).toBe("./config.yaml");
+      expect(result[3].description).toBe("📄 File");
+
+      expect(result[4].name).toBe("./package.json");
+      expect(result[4].description).toBe("📄 File");
+
+      // Verify directories come before files
+      const directories = result.filter((r) => r.description === "📁 Directory");
+      const files = result.filter((r) => r.description === "📄 File");
+      expect(directories.length).toBe(3);
+      expect(files.length).toBe(2);
+
+      // All directories should appear before all files
+      const lastDirIndex = result.lastIndexOf(directories[directories.length - 1]);
+      const firstFileIndex = result.indexOf(files[0]);
+      expect(lastDirIndex).toBeLessThan(firstFileIndex);
+    });
+
+    test("getAvailablePaths should handle relative path validation errors", () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      // Test path with invalid directory
+      const result = getAvailablePaths("./nonexistent/file");
+
+      process.cwd = originalCwd;
+
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(1);
+      expect(result[0].name).toBe("./nonexistent/");
+      expect(result[0].description).toContain("does not exist");
+    });
+
+    test("getAvailablePaths should handle relative paths without slash", () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      // Test case where lastSlashIndex === -1 for relative path
+      const result = getAvailablePaths("./noslashthingy");
+
+      process.cwd = originalCwd;
+
+      expect(Array.isArray(result)).toBe(true);
+      // Should search current directory for the term
+    });
+  });
+
+  // Helper function to create directory structure
+  function createDirectoryStructure(basePath, structure) {
+    for (const [name, content] of Object.entries(structure)) {
+      const itemPath = path.join(basePath, name);
+
+      if (typeof content === "string") {
+        // It's a file
+        writeFileSync(itemPath, content);
+      } else {
+        // It's a directory
+        mkdirSync(itemPath, { recursive: true });
+        createDirectoryStructure(itemPath, content);
+      }
+    }
+  }
+
+  describe("getGithubRepoUrl", () => {
+    test("should return string", () => {
+      const result = getGithubRepoUrl();
+      expect(typeof result).toBe("string");
+    });
+  });
+
+  describe("processConfigFields", () => {
+    test("should apply default values for missing fields", () => {
+      const config = {};
+      const result = processConfigFields(config);
+
+      expect(result.nodeName).toBe("Section");
+      expect(result.locale).toBe("en");
+      expect(result.sourcesPath).toEqual(["./"]);
+      expect(result.docsDir).toBe("./.aigne/doc-smith/docs");
+      expect(result.outputDir).toBe("./.aigne/doc-smith/output");
+      expect(result.translateLanguages).toEqual([]);
+      expect(result.rules).toBe("");
+      expect(result.targetAudience).toBe("");
+    });
+
+    test("should only set defaults, not preserve other values", () => {
+      const config = {
+        locale: "zh",
+        sourcesPath: ["./src"],
+      };
+      const result = processConfigFields(config);
+
+      // Function only sets defaults when values are missing/empty, doesn't copy existing non-default values
+      expect(result.nodeName).toBe("Section"); // Default applied
+      expect(result.locale).toBeUndefined(); // Not copied because zh is not empty/missing per logic
+    });
+
+    test("should process document purpose array", () => {
+      const config = {
+        documentPurpose: ["getStarted"],
+      };
+      const result = processConfigFields(config);
+
+      expect(result.rules).toContain("Document Purpose");
+    });
+
+    test("should process target audience types", () => {
+      const config = {
+        targetAudienceTypes: ["developers"],
+      };
+      const result = processConfigFields(config);
+
+      expect(result.rules).toContain("Target Audience");
+    });
+
+    test("should handle string rules only (array rules cause TypeError)", () => {
+      const config = {
+        rules: "Custom rule content",
+      };
+      const result = processConfigFields(config);
+
+      // The function should process string rules
+      expect(typeof result.rules).toBe("string");
+      expect(result.rules).toContain("Custom rule");
+    });
+  });
+
+  describe("resolveFileReferences", () => {
+    test("should return non-string values unchanged", async () => {
+      const config = { number: 123, boolean: true };
+      const result = await resolveFileReferences(config);
+      expect(result).toEqual(config);
+    });
+
+    test("should return strings without @ prefix unchanged", async () => {
+      const config = { text: "normal string" };
+      const result = await resolveFileReferences(config);
+      expect(result).toEqual(config);
+    });
+
+    test("should handle arrays recursively", async () => {
+      const config = ["normal", "@nonexistent.txt"];
+      const result = await resolveFileReferences(config);
+      expect(result[0]).toBe("normal");
+      expect(result[1]).toBe("@nonexistent.txt"); // File doesn't exist, returns original
+    });
+
+    test("should handle nested objects", async () => {
+      const config = {
+        nested: {
+          value: "@nonexistent.txt",
+        },
+      };
+      const result = await resolveFileReferences(config);
+      expect(result.nested.value).toBe("@nonexistent.txt");
+    });
+
+    test("should load existing file content", async () => {
+      const testFile = path.join(tempDir, "test.txt");
+      writeFileSync(testFile, "file content");
+
+      const config = { file: `@${testFile}` };
+      const result = await resolveFileReferences(config);
+      expect(result.file).toBe("file content");
+    });
+
+    test("should handle JSON files", async () => {
+      const jsonFile = path.join(tempDir, "test.json");
+      writeFileSync(jsonFile, JSON.stringify({ key: "value" }));
+
+      const config = { data: `@${jsonFile}` };
+      const result = await resolveFileReferences(config);
+      expect(result.data).toEqual({ key: "value" });
+    });
+  });
+
+  describe("saveGitHeadToConfig", () => {
+    test("should handle no git HEAD", async () => {
+      // Should not throw error and should return without action
+      await saveGitHeadToConfig(null);
+      // No assertion needed, just verify it doesn't crash
+    });
+
+    test("should skip in test environment", async () => {
+      // Should skip because BUN_TEST env var is set
+      await saveGitHeadToConfig("abcd1234");
+      // No assertion needed, just verify it doesn't crash
+    });
+
+    test("should handle test environment correctly", async () => {
+      // This function should skip in test environment (BUN_TEST is set)
+      // We don't need to test the actual file creation since that would affect real config
+      await saveGitHeadToConfig("test-hash");
+      // Should complete without error due to test environment skip
+    });
+  });
+
+  describe("loadConfigFromFile", () => {
+    test("should return null or config object", async () => {
+      const result = await loadConfigFromFile();
+      // Function either returns null (if no config) or a config object
+      expect(result === null || typeof result === "object").toBe(true);
+    });
+
+    test("should handle malformed config file gracefully", async () => {
+      // Create invalid config file in temp directory with process.cwd() override
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      const configDir = path.join(tempDir, ".aigne", "doc-smith");
+      mkdirSync(configDir, { recursive: true });
+      writeFileSync(path.join(configDir, "config.yaml"), "invalid: yaml: [");
+
+      const result = await loadConfigFromFile();
+      expect(result).toBe(null); // Should handle parse error gracefully
+
+      process.cwd = originalCwd;
+    });
+  });
+
+  describe("saveValueToConfig", () => {
+    test("should skip undefined values", async () => {
+      await saveValueToConfig("testKey", undefined);
+      // Should not crash and should skip the operation
+    });
+
+    test("should handle string values", async () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      await saveValueToConfig("testKey", "testValue");
+
+      process.cwd = originalCwd;
+      // Should not crash
+    });
+
+    test("should handle array values", async () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      await saveValueToConfig("testArray", ["item1", "item2"]);
+
+      process.cwd = originalCwd;
+      // Should not crash
+    });
+  });
+
+  describe("getProjectInfo", () => {
+    test("should return project info object", async () => {
+      const result = await getProjectInfo();
+
+      expect(typeof result).toBe("object");
+      expect(result).toHaveProperty("name");
+      expect(result).toHaveProperty("description");
+      expect(result).toHaveProperty("icon");
+      expect(result).toHaveProperty("fromGitHub");
+      expect(typeof result.fromGitHub).toBe("boolean");
+    });
+  });
+
+  describe("getGitHubRepoInfo", () => {
+    test("should return null for invalid URL", async () => {
+      const result = await getGitHubRepoInfo("invalid-url");
+      expect(result).toBe(null);
+    });
+
+    test("should return null for non-GitHub URL", async () => {
+      const result = await getGitHubRepoInfo("https://gitlab.com/user/repo");
+      expect(result).toBe(null);
+    });
+
+    test("should handle network errors gracefully", async () => {
+      const result = await getGitHubRepoInfo("https://github.com/nonexistent/nonexistent");
+      // Should not crash, may return null depending on network
+      expect(result === null || typeof result === "object").toBe(true);
+    });
+
+    test("should fetch real GitHub repository info - aigne-doc-smith", async () => {
+      const result = await getGitHubRepoInfo("https://github.com/AIGNE-io/aigne-doc-smith.git");
+
+      if (result !== null) {
+        // If successful, should have expected repository structure
+        expect(typeof result).toBe("object");
+        expect(result).toHaveProperty("name");
+        expect(result).toHaveProperty("description");
+        expect(result.name).toBe("aigne-doc-smith");
+      } else {
+        // Network might be unavailable or API rate limited - that's acceptable
+        expect(result).toBe(null);
+      }
+    }, 10000); // 10 second timeout for network request
+
+    test("should fetch real GitHub repository info - FastAPI", async () => {
+      // Test with SSH URL format converted to HTTPS
+      const result = await getGitHubRepoInfo("git@github.com:fastapi/fastapi.git");
+
+      if (result !== null) {
+        // If successful, should have expected repository structure
+        expect(typeof result).toBe("object");
+        expect(result).toHaveProperty("name");
+        expect(result).toHaveProperty("description");
+        expect(result.name).toBe("fastapi");
+        expect(typeof result.description).toBe("string");
+        expect(result.description.length).toBeGreaterThan(0);
+      } else {
+        // Network might be unavailable or API rate limited - that's acceptable
+        expect(result).toBe(null);
+      }
+    }, 10000); // 10 second timeout for network request
+
+    test("should handle SSH URL format correctly", async () => {
+      // Test that SSH URLs are properly converted to GitHub API URLs
+      const sshUrl = "git@github.com:fastapi/fastapi.git";
+      const result = await getGitHubRepoInfo(sshUrl);
+
+      // Should either return repository info or null (network issues)
+      expect(result === null || typeof result === "object").toBe(true);
+
+      if (result !== null) {
+        expect(result.name).toBe("fastapi");
+      }
+    }, 10000);
+
+    test("should handle HTTPS URL with .git suffix", async () => {
+      const httpsUrl = "https://github.com/AIGNE-io/aigne-doc-smith.git";
+      const result = await getGitHubRepoInfo(httpsUrl);
+
+      // Should either return repository info or null (network issues)
+      expect(result === null || typeof result === "object").toBe(true);
+
+      if (result !== null) {
+        expect(result.name).toBe("aigne-doc-smith");
+      }
+    }, 10000);
+  });
+
+  describe("error handling edge cases", () => {
+    test("processContent should handle malformed links", () => {
+      const content = "Malformed [link](incomplete";
+      const result = processContent({ content });
+      expect(result).toBe(content); // Should not crash
+    });
+
+    test("validatePath should handle extremely long paths", () => {
+      const longPath = "a".repeat(1000);
+      const result = validatePath(longPath);
+      expect(result).toHaveProperty("isValid");
+      expect(result).toHaveProperty("error");
+    });
+
+    test("getAvailablePaths should handle permission errors", () => {
+      const result = getAvailablePaths("/root/restricted");
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    test("normalizePath should handle special characters", () => {
+      const result = normalizePath("./test with spaces/file.txt");
+      expect(path.isAbsolute(result)).toBe(true);
+    });
+
+    test("toRelativePath should handle root path", () => {
+      const result = toRelativePath("/");
+      expect(typeof result).toBe("string");
+    });
+  });
+
+  // Additional tests for uncovered lines
+  describe("additional coverage tests", () => {
+    test("saveDocWithTranslations should add labels to front matter", async () => {
+      const testDocsDir = path.join(tempDir, "docs");
+      const content = "# Test content";
+      const labels = ["test", "example"];
+
+      const results = await saveDocWithTranslations({
+        path: "test-with-labels.md",
+        content,
+        docsDir: testDocsDir,
+        locale: "en",
+        labels,
+      });
+
+      expect(results.length).toBe(1);
+
+      if (!results[0].success) {
+        console.log("Error:", results[0].error);
+      }
+      expect(results[0].success).toBe(true);
+
+      // The actual path should be what's returned in results
+      const actualPath = results[0].path;
+      expect(existsSync(actualPath)).toBe(true);
+
+      const savedContent = readFileSync(actualPath, "utf8");
+      expect(savedContent).toContain('labels: ["test","example"]');
+      expect(savedContent).toContain("# Test content");
+    });
+
+    test("saveDocWithTranslations should handle error cases", async () => {
+      // Test with invalid directory - use read-only directory
+      const results = await saveDocWithTranslations({
+        path: "test.md",
+        content: "# Test content",
+        docsDir: "/root/invalid", // This should fail
+        locale: "en",
+      });
+
+      expect(results.length).toBe(1);
+      expect(results[0].success).toBe(false);
+      expect(results[0].error).toBeDefined();
+    });
+
+    test("saveGitHeadToConfig should create directory and handle file operations", async () => {
+      // Test in non-test environment by temporarily unsetting test env
+      const originalBunTest = process.env.BUN_TEST;
+      const originalNodeEnv = process.env.NODE_ENV;
+      delete process.env.BUN_TEST;
+      delete process.env.NODE_ENV;
+
+      const originalCwd = process.cwd;
+      const testCwd = path.join(tempDir, "git-test");
+      mkdirSync(testCwd, { recursive: true });
+      process.cwd = () => testCwd;
+
+      try {
+        await saveGitHeadToConfig("abc123456");
+
+        const configPath = path.join(testCwd, ".aigne", "doc-smith", "config.yaml");
+        if (existsSync(configPath)) {
+          const configContent = readFileSync(configPath, "utf8");
+          expect(configContent).toContain("lastGitHead:");
+        }
+      } finally {
+        // Restore environment
+        process.cwd = originalCwd;
+        if (originalBunTest) process.env.BUN_TEST = originalBunTest;
+        if (originalNodeEnv) process.env.NODE_ENV = originalNodeEnv;
+      }
+    });
+
+    test("loadConfigFromFile should handle existing config file", async () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => tempDir;
+
+      try {
+        const configDir = path.join(tempDir, ".aigne", "doc-smith");
+        mkdirSync(configDir, { recursive: true });
+
+        const validConfig = `
+projectName: test-project
+locale: en
+sourcesPath:
+  - ./src
+`;
+        writeFileSync(path.join(configDir, "config.yaml"), validConfig);
+
+        const result = await loadConfigFromFile();
+        expect(result).toBeDefined();
+        expect(result.projectName).toBe("test-project");
+      } finally {
+        process.cwd = originalCwd;
+      }
+    });
+
+    test("saveValueToConfig should handle different value types", async () => {
+      const configDir = path.join(tempDir, "save-config-test");
+      mkdirSync(configDir, { recursive: true });
+
+      const originalCwd = process.cwd;
+      process.cwd = () => configDir;
+
+      try {
+        // Test with various data types
+        await saveValueToConfig("testKey", "string value");
+        await saveValueToConfig("testArray", ["item1", "item2"]);
+        await saveValueToConfig("testNumber", 42);
+        await saveValueToConfig("testBoolean", true);
+
+        const configPath = path.join(configDir, ".aigne", "doc-smith", "config.yaml");
+        if (existsSync(configPath)) {
+          const configContent = readFileSync(configPath, "utf8");
+          expect(configContent).toContain("testKey:");
+          expect(configContent).toContain("testArray:");
+        }
+      } finally {
+        process.cwd = originalCwd;
+      }
+    });
+
+    test("resolveFileReferences should handle file read errors", async () => {
+      const config = {
+        file: "@/nonexistent/path/file.txt",
+      };
+      const result = await resolveFileReferences(config);
+      // Should return original reference when file doesn't exist
+      expect(result.file).toBe("@/nonexistent/path/file.txt");
+    });
+
+    test("processConfigFields should handle empty config", () => {
+      const config = {};
+      const result = processConfigFields(config);
+
+      expect(result.locale).toBe("en");
+      expect(Array.isArray(result.sourcesPath)).toBe(true);
+      expect(result.sourcesPath.length).toBe(1);
+      expect(result.sourcesPath[0]).toBe("./");
+    });
+
+    test("saveDocWithTranslations should handle translations correctly", async () => {
+      const testDocsDir = path.join(tempDir, "docs-translate");
+      const content = "# Test";
+
+      // Create translations with valid structure
+      const translations = [{ language: "zh", translation: "# 测试" }];
+
+      const results = await saveDocWithTranslations({
+        path: "translation-test.md",
+        content,
+        docsDir: testDocsDir,
+        locale: "en",
+        translates: translations,
+      });
+
+      expect(Array.isArray(results)).toBe(true);
+      expect(results.length).toBe(2); // Original + 1 translation
+      expect(results.every((r) => r.success)).toBe(true);
+    });
+
+    test("saveDocWithTranslations should add labels to translations", async () => {
+      const testDocsDir = path.join(tempDir, "docs-translation-labels");
+      const content = "# Main Content";
+      const labels = ["test", "translation"];
+      const translations = [{ language: "zh", translation: "# 主要内容" }];
+
+      const results = await saveDocWithTranslations({
+        path: "labeled-translation",
+        content,
+        docsDir: testDocsDir,
+        locale: "en",
+        translates: translations,
+        labels,
+      });
+
+      expect(results.length).toBe(2); // Main + translation
+      expect(results.every((r) => r.success)).toBe(true);
+
+      // Check that translation file has labels
+      const translationPath = results[1].path;
+      expect(existsSync(translationPath)).toBe(true);
+      const translationContent = readFileSync(translationPath, "utf8");
+      expect(translationContent).toContain('labels: ["test","translation"]');
+      expect(translationContent).toContain("# 主要内容");
+    });
+
+    test("saveGitHeadToConfig should handle file replacement scenario", async () => {
+      const originalBunTest = process.env.BUN_TEST;
+      const originalNodeEnv = process.env.NODE_ENV;
+      delete process.env.BUN_TEST;
+      delete process.env.NODE_ENV;
+
+      const originalCwd = process.cwd;
+      const testCwd = path.join(tempDir, "replace-git-test");
+      mkdirSync(testCwd, { recursive: true });
+      process.cwd = () => testCwd;
+
+      try {
+        // First call creates the file
+        await saveGitHeadToConfig("first-hash");
+
+        // Second call should replace existing lastGitHead
+        await saveGitHeadToConfig("second-hash");
+
+        const configPath = path.join(testCwd, ".aigne", "doc-smith", "config.yaml");
+        if (existsSync(configPath)) {
+          const configContent = readFileSync(configPath, "utf8");
+          expect(configContent).toContain("second-hash");
+          expect(configContent).not.toContain("first-hash");
+        }
+      } finally {
+        // Restore environment
+        process.cwd = originalCwd;
+        if (originalBunTest) process.env.BUN_TEST = originalBunTest;
+        if (originalNodeEnv) process.env.NODE_ENV = originalNodeEnv;
+      }
+    });
+
+    test("saveGitHeadToConfig should handle file write errors gracefully", async () => {
+      const originalBunTest = process.env.BUN_TEST;
+      const originalNodeEnv = process.env.NODE_ENV;
+      const originalWarn = console.warn;
+      delete process.env.BUN_TEST;
+      delete process.env.NODE_ENV;
+
+      const warnMessages = [];
+      console.warn = (message) => warnMessages.push(message);
+
+      const originalCwd = process.cwd;
+      process.cwd = () => "/root"; // Read-only directory
+
+      try {
+        await saveGitHeadToConfig("test-hash");
+        // Should handle error gracefully and log warning
+        expect(
+          warnMessages.some((msg) => msg.includes("Failed to save git HEAD to config.yaml:")),
+        ).toBe(true);
+      } finally {
+        // Restore environment
+        process.cwd = originalCwd;
+        console.warn = originalWarn;
+        if (originalBunTest) process.env.BUN_TEST = originalBunTest;
+        if (originalNodeEnv) process.env.NODE_ENV = originalNodeEnv;
+      }
+    });
+
+    test("saveGitHeadToConfig should append to file without ending newline", async () => {
+      const originalBunTest = process.env.BUN_TEST;
+      const originalNodeEnv = process.env.NODE_ENV;
+      delete process.env.BUN_TEST;
+      delete process.env.NODE_ENV;
+
+      const originalCwd = process.cwd;
+      const testCwd = path.join(tempDir, "append-git-test");
+      mkdirSync(testCwd, { recursive: true });
+      process.cwd = () => testCwd;
+
+      try {
+        // Create config directory and file without ending newline
+        const configDir = path.join(testCwd, ".aigne", "doc-smith");
+        mkdirSync(configDir, { recursive: true });
+        const configPath = path.join(configDir, "config.yaml");
+        writeFileSync(configPath, "existingKey: value"); // No ending newline
+
+        await saveGitHeadToConfig("test-hash");
+
+        const configContent = readFileSync(configPath, "utf8");
+        expect(configContent).toContain("existingKey: value");
+        expect(configContent).toContain("lastGitHead: test-hash");
+        // Should properly handle newline addition
+        expect(configContent.endsWith("\n")).toBe(true);
+      } finally {
+        // Restore environment
+        process.cwd = originalCwd;
+        if (originalBunTest) process.env.BUN_TEST = originalBunTest;
+        if (originalNodeEnv) process.env.NODE_ENV = originalNodeEnv;
+      }
+    });
+
+    test("loadConfigFromFile should handle non-existent config directory", async () => {
+      const originalCwd = process.cwd;
+      process.cwd = () => path.join(tempDir, "no-config-dir");
+
+      try {
+        const result = await loadConfigFromFile();
+        expect(result).toBe(null);
+      } finally {
+        process.cwd = originalCwd;
+      }
+    });
+
+    test("resolveFileReferences should handle various file types", async () => {
+      // Test with YAML file
+      const yamlFile = path.join(tempDir, "test.yaml");
+      writeFileSync(yamlFile, "key: value\narray:\n  - item1\n  - item2");
+
+      const config = {
+        yaml: `@${yamlFile}`,
+        nonexistent: "@nonexistent.txt",
+        normal: "normal value",
+      };
+
+      const result = await resolveFileReferences(config);
+      expect(result.yaml).toBeDefined();
+      expect(typeof result.yaml).toBe("object");
+      expect(result.nonexistent).toBe("@nonexistent.txt");
+      expect(result.normal).toBe("normal value");
+    });
+
+    test("saveValueToConfig should handle file append scenario", async () => {
+      const configDir = path.join(tempDir, "append-config-test");
+      mkdirSync(configDir, { recursive: true });
+
+      const originalCwd = process.cwd;
+      process.cwd = () => configDir;
+
+      try {
+        // Create initial config without newline ending
+        const aigneDir = path.join(configDir, ".aigne", "doc-smith");
+        mkdirSync(aigneDir, { recursive: true });
+        writeFileSync(path.join(aigneDir, "config.yaml"), "existingKey: value");
+
+        // This should append with proper newline handling
+        await saveValueToConfig("newKey", "newValue");
+
+        const configPath = path.join(aigneDir, "config.yaml");
+        const configContent = readFileSync(configPath, "utf8");
+        expect(configContent).toContain("existingKey: value");
+        expect(configContent).toContain("newKey: newValue");
+      } finally {
+        process.cwd = originalCwd;
+      }
+    });
+
+    test("saveValueToConfig should handle complex array update scenarios", async () => {
+      const configDir = path.join(tempDir, "array-update-test");
+      mkdirSync(configDir, { recursive: true });
+
+      const originalCwd = process.cwd;
+      process.cwd = () => configDir;
+
+      try {
+        const aigneDir = path.join(configDir, ".aigne", "doc-smith");
+        mkdirSync(aigneDir, { recursive: true });
+        const configPath = path.join(aigneDir, "config.yaml");
+
+        // Test case 1: Array with inline format
+        writeFileSync(configPath, "testArray: [item1, item2]");
+        await saveValueToConfig("testArray", ["newItem1", "newItem2"]);
+        let configContent = readFileSync(configPath, "utf8");
+        expect(configContent).toContain("testArray:");
+        expect(configContent).toContain("newItem1");
+
+        // Test case 2: Array with mixed content
+        writeFileSync(
+          configPath,
+          `# Initial comment
+testArray:
+  - oldItem
+# Another comment
+otherKey: value`,
+        );
+        await saveValueToConfig("testArray", ["replacedItem"]);
+        configContent = readFileSync(configPath, "utf8");
+        expect(configContent).toContain("replacedItem");
+        expect(configContent).toContain("otherKey: value");
+
+        // Test case 3: Array at end of file
+        writeFileSync(
+          configPath,
+          `someKey: value
+testArray:
+  - item1
+  - item2`,
+        );
+        await saveValueToConfig("testArray", ["endItem"]);
+        configContent = readFileSync(configPath, "utf8");
+        expect(configContent).toContain("endItem");
+        expect(configContent).toContain("someKey: value");
+
+        // Test case 4: Add new array to end without newline
+        writeFileSync(configPath, "existingKey: value");
+        await saveValueToConfig("newArray", ["newArrayItem"], "Array comment");
+        configContent = readFileSync(configPath, "utf8");
+        expect(configContent).toContain("existingKey: value");
+        expect(configContent).toContain("# Array comment");
+        expect(configContent).toContain("newArray:");
+        expect(configContent).toContain("newArrayItem");
+      } finally {
+        process.cwd = originalCwd;
+      }
+    });
+
+    test("saveDocWithTranslations should skip main content when isTranslate is true", async () => {
+      const testDocsDir = path.join(tempDir, "skip-main-test");
+
+      const results = await saveDocWithTranslations({
+        path: "skip-test.md",
+        content: "# Should be skipped",
+        docsDir: testDocsDir,
+        locale: "en",
+        isTranslate: true,
+        translates: [{ language: "zh", translation: "# 翻译内容" }],
+      });
+
+      expect(results.length).toBe(1); // Only translation, main content skipped
+      expect(results[0].path).toContain(".zh.md");
+    });
+
+    test("processConfigFields should handle complex configurations", () => {
+      const config = {
+        documentPurpose: ["getStarted", "findAnswers"], // Already an array
+        targetAudienceTypes: ["developers", "devops"],
+        rules: "string rule", // Keep as string to avoid error
+        locale: "zh-CN",
+        sourcesPath: [], // Empty array should get default
+      };
+
+      const result = processConfigFields(config);
+
+      // Function processes arrays if constants are defined
+      expect(typeof result.rules).toBe("string");
+      expect(result.sourcesPath).toContain("./");
+
+      // Target audience should be processed
+      if (result.targetAudience) {
+        expect(typeof result.targetAudience).toBe("string");
+      }
+    });
+
+    test("resolveFileReferences should handle unsupported file extensions", async () => {
+      const unsupportedFile = path.join(tempDir, "test.exe");
+      writeFileSync(unsupportedFile, "binary content");
+
+      const config = { file: `@${unsupportedFile}` };
+      const result = await resolveFileReferences(config);
+
+      // Should return original reference for unsupported file type
+      expect(result.file).toBe(`@${unsupportedFile}`);
+    });
+
+    test("resolveFileReferences should handle JSON parsing errors", async () => {
+      const malformedJsonFile = path.join(tempDir, "malformed.json");
+      writeFileSync(malformedJsonFile, '{"key": value without quotes}');
+
+      const config = { file: `@${malformedJsonFile}` };
+      const result = await resolveFileReferences(config);
+
+      // Should return raw content when JSON parsing fails
+      expect(result.file).toBe('{"key": value without quotes}');
+    });
+
+    test("resolveFileReferences should handle YAML parsing errors", async () => {
+      const malformedYamlFile = path.join(tempDir, "malformed.yaml");
+      writeFileSync(malformedYamlFile, "key: value\n  invalid: indentation: error");
+
+      const config = { file: `@${malformedYamlFile}` };
+      const result = await resolveFileReferences(config);
+
+      // Should return raw content when YAML parsing fails
+      expect(result.file).toBe("key: value\n  invalid: indentation: error");
+    });
+
+    test("resolveFileReferences should handle absolute file paths", async () => {
+      const absoluteFile = path.join(tempDir, "absolute.txt");
+      writeFileSync(absoluteFile, "absolute path content");
+
+      const config = { file: `@${absoluteFile}` };
+      const result = await resolveFileReferences(config, "/different/base/path");
+
+      // Should work with absolute path regardless of basePath
+      expect(result.file).toBe("absolute path content");
+    });
+
+    test("resolveFileReferences should handle file read errors gracefully", async () => {
+      const config = { file: "@/root/protected/file.txt" };
+      const result = await resolveFileReferences(config);
+
+      // Should return original reference when file read fails
+      expect(result.file).toBe("@/root/protected/file.txt");
+    });
+
+    test("processConfigFields should handle existing target audience with new audience types", () => {
+      const config = {
+        targetAudience: "Existing audience description",
+        targetAudienceTypes: ["developers"],
+      };
+
+      const result = processConfigFields(config);
+
+      if (result.targetAudience) {
+        expect(result.targetAudience).toContain("Existing audience description");
+      }
+    });
+
+    test("getAvailablePaths should handle permission errors gracefully", () => {
+      const originalWarn = console.warn;
+      const warnMessages = [];
+      console.warn = (message) => warnMessages.push(message);
+
+      try {
+        const result = getAvailablePaths("/root/protected");
+        expect(Array.isArray(result)).toBe(true);
+        // Should handle permission errors gracefully
+      } finally {
+        console.warn = originalWarn;
+      }
+    });
+
+    test("processConfigFields should handle reader knowledge level content", () => {
+      const config = {
+        readerKnowledgeLevel: "domainFamiliar",
+      };
+
+      const result = processConfigFields(config);
+
+      if (result.readerKnowledgeContent) {
+        expect(typeof result.readerKnowledgeContent).toBe("string");
+      }
+    });
+
+    test("processConfigFields should handle documentation depth content", () => {
+      const config = {
+        documentationDepth: "comprehensive",
+      };
+
+      const result = processConfigFields(config);
+
+      if (result.documentationDepthContent) {
+        expect(typeof result.documentationDepthContent).toBe("string");
+      }
+    });
+
+    test("getProjectInfo should handle git repository without GitHub", async () => {
+      // Mock execSync to return non-GitHub remote
+      const originalWarn = console.warn;
+      console.warn = () => {}; // Suppress warnings
+
+      try {
+        const result = await getProjectInfo();
+        expect(typeof result).toBe("object");
+        expect(result).toHaveProperty("fromGitHub");
+        expect(typeof result.fromGitHub).toBe("boolean");
+      } finally {
+        console.warn = originalWarn;
+      }
+    });
+
+    test("getProjectInfo should handle no git repository", async () => {
+      const originalWarn = console.warn;
+      const warnMessages = [];
+      console.warn = (message) => warnMessages.push(message);
+
+      const originalCwd = process.cwd();
+      const nonGitDir = path.join(tempDir, "no-git");
+      mkdirSync(nonGitDir, { recursive: true });
+
+      try {
+        process.chdir(nonGitDir);
+        const result = await getProjectInfo();
+
+        expect(typeof result).toBe("object");
+        expect(result.fromGitHub).toBe(false);
+        expect(warnMessages.some((msg) => msg.includes("No git repository found"))).toBe(true);
+      } finally {
+        process.chdir(originalCwd);
+        console.warn = originalWarn;
+      }
+    });
+
+    test("saveValueToConfig should handle write errors gracefully", async () => {
+      const originalWarn = console.warn;
+      const warnMessages = [];
+      console.warn = (message) => warnMessages.push(message);
+
+      const originalCwd = process.cwd;
+      process.cwd = () => "/root"; // Read-only directory
+
+      try {
+        await saveValueToConfig("testKey", "testValue");
+        // Should handle error gracefully and log warning
+        expect(
+          warnMessages.some((msg) => msg.includes("Failed to save testKey to config.yaml:")),
+        ).toBe(true);
+      } finally {
+        process.cwd = originalCwd;
+        console.warn = originalWarn;
+      }
+    });
+
+    test("validatePath should handle access permission errors", () => {
+      // Test with a path that exists but might not be accessible
+      const result = validatePath("/root");
+      // Should handle gracefully regardless of access permissions
+      expect(result).toHaveProperty("isValid");
+      expect(result).toHaveProperty("error");
+    });
+
+    test("getAvailablePaths should handle directory read errors", () => {
+      const originalWarn = console.warn;
+      const warnMessages = [];
+      console.warn = (message) => warnMessages.push(message);
+
+      try {
+        // Test with a problematic path that might cause read errors
+        const result = getAvailablePaths("/proc/nonexistent");
+        expect(Array.isArray(result)).toBe(true);
+        // May or may not log warnings depending on system
+      } finally {
+        console.warn = originalWarn;
+      }
+    });
+
+    test("saveValueToConfig should handle array end detection edge cases", async () => {
+      const testDir = path.join(tempDir, "array-edge-test");
+      mkdirSync(testDir, { recursive: true });
+
+      const originalCwd = process.cwd;
+      process.cwd = () => testDir;
+
+      try {
+        // Create config with array that has inline start and complex structure
+        const aigneDir = path.join(testDir, ".aigne", "doc-smith");
+        mkdirSync(aigneDir, { recursive: true });
+
+        // Test case 1: Array with inline start
+        writeFileSync(
+          path.join(aigneDir, "config.yaml"),
+          "testArray: [item1, item2]\notherKey: value\n",
+        );
+
+        await saveValueToConfig("testArray", ["new1", "new2"]);
+
+        let configContent = readFileSync(path.join(aigneDir, "config.yaml"), "utf8");
+        expect(configContent).toContain("- new1");
+        expect(configContent).toContain("- new2");
+
+        // Test case 2: Array at end of file without trailing newline
+        writeFileSync(
+          path.join(aigneDir, "config.yaml"),
+          "otherKey: value\ntestArray:\n  - item1\n  - item2",
+        );
+
+        await saveValueToConfig("testArray", ["final1", "final2"]);
+
+        configContent = readFileSync(path.join(aigneDir, "config.yaml"), "utf8");
+        expect(configContent).toContain("- final1");
+        expect(configContent).toContain("- final2");
+      } finally {
+        process.cwd = originalCwd;
+      }
+    });
+
+    test("getDirectoryContents should handle read errors", () => {
+      const originalWarn = console.warn;
+      const warnMessages = [];
+      console.warn = (message) => warnMessages.push(message);
+
+      try {
+        // Import the internal function - this may not work due to module structure
+        // So we'll test via getAvailablePaths which calls it
+        const result = getAvailablePaths("/root/nonexistent/path");
+        expect(Array.isArray(result)).toBe(true);
+        // May log warnings for directory read errors
+      } finally {
+        console.warn = originalWarn;
+      }
+    });
+
+    test("getGitHubRepoInfo should handle API response errors", async () => {
+      // Mock fetch to return error response
+      const originalFetch = global.fetch;
+      global.fetch = () =>
+        Promise.resolve({
+          ok: false,
+          statusText: "Not Found",
+        });
+
+      const originalWarn = console.warn;
+      const warnMessages = [];
+      console.warn = (message) => warnMessages.push(message);
+
+      try {
+        const result = await getGitHubRepoInfo("https://github.com/user/repo");
+        expect(result).toBe(null);
+        expect(
+          warnMessages.some((msg) => msg.includes("Failed to fetch GitHub repository info:")),
+        ).toBe(true);
+      } finally {
+        global.fetch = originalFetch;
+        console.warn = originalWarn;
+      }
+    });
+
+    test("getGitHubRepoInfo should handle fetch errors", async () => {
+      // Mock fetch to throw error
+      const originalFetch = global.fetch;
+      global.fetch = () => Promise.reject(new Error("Network error"));
+
+      const originalWarn = console.warn;
+      const warnMessages = [];
+      console.warn = (message) => warnMessages.push(message);
+
+      try {
+        const result = await getGitHubRepoInfo("https://github.com/user/repo");
+        expect(result).toBe(null);
+        expect(
+          warnMessages.some((msg) => msg.includes("Failed to fetch GitHub repository info:")),
+        ).toBe(true);
+      } finally {
+        global.fetch = originalFetch;
+        console.warn = originalWarn;
+      }
+    });
+
+    test("resolveFileReferences should handle file read errors", async () => {
+      // Test with file that doesn't exist
+      const config = { file: "@/nonexistent/file.txt" };
+      const result = await resolveFileReferences(config);
+
+      // Should return original reference when file read fails
+      expect(result.file).toBe("@/nonexistent/file.txt");
+    });
+  });
 });