@interactive-inc/docs-client 1.0.20 → 1.1.0

package/build/file-system-mock.js

@@ -0,0 +1,901 @@
+// lib/modules/path-system/doc-path-system.ts
+var DocPathSystem = class {
+  separator = "/";
+  /**
+   * Join paths
+   */
+  join(...paths) {
+    const parts = [];
+    for (const path of paths) {
+      if (path === "") continue;
+      const segments = path.split(this.separator).filter(Boolean);
+      parts.push(...segments);
+    }
+    if (parts.length === 0) {
+      return ".";
+    }
+    const isAbsolute = paths[0]?.startsWith(this.separator);
+    const joined = parts.join(this.separator);
+    return isAbsolute ? `${this.separator}${joined}` : joined;
+  }
+  /**
+   * Get filename with extension
+   */
+  basename(path, ext) {
+    const segments = path.split(this.separator);
+    const filename = segments[segments.length - 1] || "";
+    if (ext && filename.endsWith(ext)) {
+      return filename.slice(0, -ext.length);
+    }
+    return filename;
+  }
+  /**
+   * Get directory name
+   */
+  dirname(path) {
+    const segments = path.split(this.separator);
+    if (segments.length <= 1) {
+      return ".";
+    }
+    segments.pop();
+    const dir = segments.join(this.separator);
+    return dir || ".";
+  }
+  /**
+   * Get extension
+   */
+  extname(path) {
+    const basename = this.basename(path);
+    const lastDot = basename.lastIndexOf(".");
+    if (lastDot <= 0) {
+      return "";
+    }
+    return basename.slice(lastDot);
+  }
+  /**
+   * Calculate relative path
+   */
+  relative(from, to) {
+    const fromSegments = from.split(this.separator).filter(Boolean);
+    const toSegments = to.split(this.separator).filter(Boolean);
+    let commonLength = 0;
+    for (let i = 0; i < Math.min(fromSegments.length, toSegments.length); i++) {
+      if (fromSegments[i] === toSegments[i]) {
+        commonLength++;
+      } else {
+        break;
+      }
+    }
+    const upCount = fromSegments.length - commonLength;
+    const upSegments = Array(upCount).fill("..");
+    const downSegments = toSegments.slice(commonLength);
+    const segments = [...upSegments, ...downSegments];
+    return segments.length > 0 ? segments.join(this.separator) : ".";
+  }
+  /**
+   * Convert to absolute path
+   */
+  resolve(...paths) {
+    let resolved = "";
+    for (const path of paths) {
+      if (path.startsWith(this.separator)) {
+        resolved = path;
+      } else if (path !== "") {
+        resolved = resolved ? this.join(resolved, path) : path;
+      }
+    }
+    return resolved || ".";
+  }
+  /**
+   * Normalize path
+   */
+  normalize(path) {
+    const isAbsolute = path.startsWith(this.separator);
+    const segments = path.split(this.separator).filter(Boolean);
+    const normalized = [];
+    for (const segment of segments) {
+      if (segment === "..") {
+        if (normalized.length > 0 && normalized[normalized.length - 1] !== "..") {
+          normalized.pop();
+        } else if (!isAbsolute) {
+          normalized.push("..");
+        }
+      } else if (segment !== ".") {
+        normalized.push(segment);
+      }
+    }
+    if (normalized.length === 0) {
+      return isAbsolute ? this.separator : ".";
+    }
+    const result = normalized.join(this.separator);
+    return isAbsolute ? `${this.separator}${result}` : result;
+  }
+  /**
+   * Check if path is absolute
+   */
+  isAbsolute(path) {
+    return path.startsWith(this.separator);
+  }
+};
+
+// lib/modules/file-system/doc-file-system-read.ts
+import * as fs from "fs/promises";
+var DocFileSystemRead = class {
+  basePath;
+  pathSystem;
+  constructor(props) {
+    this.basePath = props.basePath;
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+  }
+  /**
+   * Read file content at the specified path
+   */
+  async readFile(relativePath) {
+    try {
+      const exists = await this.exists(relativePath);
+      if (!exists) return null;
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      return await fs.readFile(fullPath, "utf-8");
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read file at ${relativePath}`);
+    }
+  }
+  /**
+   * Get file name from path
+   */
+  readFileName(relativePath) {
+    return this.pathSystem.basename(relativePath);
+  }
+  /**
+   * Get file extension from path
+   */
+  readFileExtension(relativePath) {
+    return this.pathSystem.extname(relativePath);
+  }
+  /**
+   * Get directory path where the file exists
+   */
+  readFileDirectory(relativePath) {
+    return this.pathSystem.dirname(relativePath);
+  }
+  /**
+   * Get list of entries in directory
+   */
+  async readDirectoryFileNames(relativePath = "") {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      return await fs.readdir(fullPath);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read directory at ${relativePath}`);
+    }
+  }
+  async readDirectoryFilePaths(relativePath) {
+    try {
+      const fileNames = await this.readDirectoryFileNames(relativePath);
+      if (fileNames instanceof Error) {
+        return fileNames;
+      }
+      return fileNames.map(
+        (fileName) => this.pathSystem.join(relativePath, fileName)
+      );
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read directory file paths at ${relativePath}`);
+    }
+  }
+  /**
+   * Check if path is a directory
+   */
+  async isDirectory(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const stats = await fs.stat(fullPath);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if path is a file
+   */
+  async isFile(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const stats = await fs.stat(fullPath);
+      return stats.isFile();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if file or directory exists
+   */
+  async exists(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      await fs.access(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if directory exists
+   */
+  async directoryExists(relativePath) {
+    return this.isDirectory(relativePath);
+  }
+  /**
+   * Check if file exists
+   */
+  async fileExists(relativePath) {
+    return this.isFile(relativePath);
+  }
+  /**
+   * Get base path
+   */
+  getBasePath() {
+    return this.basePath;
+  }
+  /**
+   * Convert relative path to absolute path
+   */
+  resolve(relativePath) {
+    return this.pathSystem.join(this.basePath, relativePath);
+  }
+  /**
+   * Get file size in bytes
+   */
+  async getFileSize(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const stats = await fs.stat(fullPath);
+      return stats.size;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file size at ${relativePath}`);
+    }
+  }
+  /**
+   * Get file last modified time
+   */
+  async getFileModifiedTime(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const stats = await fs.stat(fullPath);
+      return stats.mtime;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file modified time at ${relativePath}`);
+    }
+  }
+  /**
+   * Get file creation time
+   */
+  async getFileCreatedTime(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const stats = await fs.stat(fullPath);
+      return stats.birthtime;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file created time at ${relativePath}`);
+    }
+  }
+};
+
+// lib/modules/file-system/doc-file-system-write.ts
+import * as fs2 from "fs/promises";
+var DocFileSystemWrite = class {
+  basePath;
+  pathSystem;
+  reader;
+  constructor(props) {
+    this.basePath = props.basePath;
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    this.reader = props.reader;
+  }
+  /**
+   * Write content to file at the specified path (creates directory if needed)
+   */
+  async writeFile(relativePath, content) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const dirPath = this.pathSystem.dirname(fullPath);
+      await fs2.mkdir(dirPath, { recursive: true });
+      await fs2.writeFile(fullPath, content, "utf-8");
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to write file at ${relativePath}`);
+    }
+  }
+  /**
+   * Delete file at the specified path
+   */
+  async deleteFile(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      await fs2.unlink(fullPath);
+      return null;
+    } catch (error) {
+      return new Error(`Failed to delete file at ${relativePath}: ${error}`);
+    }
+  }
+  /**
+   * Create directory
+   */
+  async createDirectory(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      await fs2.mkdir(fullPath, { recursive: true });
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to create directory at ${relativePath}`);
+    }
+  }
+  /**
+   * Create directory if it doesn't exist
+   */
+  async ensureDirectoryExists(relativePath) {
+    try {
+      if (this.reader) {
+        const exists = await this.reader.exists(relativePath);
+        if (exists) {
+          return null;
+        }
+      }
+      const result = await this.createDirectory(relativePath);
+      if (result instanceof Error) {
+        return result;
+      }
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to ensure directory exists at ${relativePath}`);
+    }
+  }
+  /**
+   * Copy file
+   */
+  async copyFile(sourcePath, destinationPath) {
+    try {
+      const sourceFullPath = this.pathSystem.join(this.basePath, sourcePath);
+      const destFullPath = this.pathSystem.join(this.basePath, destinationPath);
+      await fs2.copyFile(sourceFullPath, destFullPath);
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(
+        `Failed to copy file from ${sourcePath} to ${destinationPath}`
+      );
+    }
+  }
+  /**
+   * Move file
+   */
+  async moveFile(sourcePath, destinationPath) {
+    try {
+      const sourceFullPath = this.pathSystem.join(this.basePath, sourcePath);
+      const destFullPath = this.pathSystem.join(this.basePath, destinationPath);
+      await fs2.rename(sourceFullPath, destFullPath);
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(
+        `Failed to move file from ${sourcePath} to ${destinationPath}`
+      );
+    }
+  }
+};
+
+// lib/modules/file-system/doc-file-system.ts
+var DocFileSystem = class {
+  reader;
+  writer;
+  basePath;
+  pathSystem;
+  constructor(props) {
+    this.basePath = props.basePath;
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    this.reader = props.reader ?? new DocFileSystemRead({
+      basePath: this.basePath,
+      pathSystem: this.pathSystem
+    });
+    this.writer = props.writer ?? new DocFileSystemWrite({
+      basePath: this.basePath,
+      pathSystem: this.pathSystem,
+      reader: this.reader
+    });
+  }
+  /**
+   * Read file content at the specified path
+   */
+  async readFile(relativePath) {
+    return this.reader.readFile(relativePath);
+  }
+  /**
+   * Write content to file at the specified path (creates directory if needed)
+   */
+  async writeFile(relativePath, content) {
+    return this.writer.writeFile(relativePath, content);
+  }
+  /**
+   * Delete file at the specified path
+   */
+  async deleteFile(relativePath) {
+    return this.writer.deleteFile(relativePath);
+  }
+  /**
+   * Get file name from path
+   */
+  readFileName(relativePath) {
+    return this.reader.readFileName(relativePath);
+  }
+  /**
+   * Get file extension from path
+   */
+  readFileExtension(relativePath) {
+    return this.reader.readFileExtension(relativePath);
+  }
+  /**
+   * Get directory path where the file exists
+   */
+  readFileDirectory(relativePath) {
+    return this.reader.readFileDirectory(relativePath);
+  }
+  /**
+   * Get list of entries in directory
+   */
+  async readDirectoryFileNames(relativePath = "") {
+    return this.reader.readDirectoryFileNames(relativePath);
+  }
+  async readDirectoryFilePaths(relativePath) {
+    return this.reader.readDirectoryFilePaths(relativePath);
+  }
+  /**
+   * Check if path is a directory
+   */
+  async isDirectory(relativePath) {
+    return this.reader.isDirectory(relativePath);
+  }
+  /**
+   * Check if path is a file
+   */
+  async isFile(relativePath) {
+    return this.reader.isFile(relativePath);
+  }
+  /**
+   * Check if file or directory exists
+   */
+  async exists(relativePath) {
+    return this.reader.exists(relativePath);
+  }
+  /**
+   * Check if directory exists
+   */
+  async directoryExists(relativePath) {
+    return this.reader.directoryExists(relativePath);
+  }
+  /**
+   * Check if file exists
+   */
+  async fileExists(relativePath) {
+    return this.reader.fileExists(relativePath);
+  }
+  /**
+   * Get base path
+   */
+  getBasePath() {
+    return this.reader.getBasePath();
+  }
+  /**
+   * Convert relative path to absolute path
+   */
+  resolve(relativePath) {
+    return this.reader.resolve(relativePath);
+  }
+  /**
+   * Create directory
+   */
+  async createDirectory(relativePath) {
+    return this.writer.createDirectory(relativePath);
+  }
+  /**
+   * Get file size in bytes
+   */
+  async getFileSize(relativePath) {
+    return this.reader.getFileSize(relativePath);
+  }
+  /**
+   * Create directory if it doesn't exist
+   */
+  async ensureDirectoryExists(relativePath) {
+    return this.writer.ensureDirectoryExists(relativePath);
+  }
+  /**
+   * Copy file
+   */
+  async copyFile(sourcePath, destinationPath) {
+    return this.writer.copyFile(sourcePath, destinationPath);
+  }
+  /**
+   * Move file
+   */
+  async moveFile(sourcePath, destinationPath) {
+    return this.writer.moveFile(sourcePath, destinationPath);
+  }
+  /**
+   * Get file last modified time
+   */
+  async getFileModifiedTime(relativePath) {
+    return this.reader.getFileModifiedTime(relativePath);
+  }
+  /**
+   * Get file creation time
+   */
+  async getFileCreatedTime(relativePath) {
+    return this.reader.getFileCreatedTime(relativePath);
+  }
+};
+
+// lib/modules/file-system/doc-file-system-mock.ts
+var mockDirectoryData = {
+  "docs/index.md": `---
+icon: \u{1F4DA}
+---
+
+# Documentation
+
+Welcome to the documentation!`,
+  "docs/guide/index.md": `---
+icon: \u{1F4D6}
+---
+
+# Guide
+
+This is a guide.`,
+  "docs/guide/getting-started.md": `# Getting Started
+
+Let's get started!`,
+  "docs/guide/advanced.md": `# Advanced
+
+Advanced topics here.`,
+  "docs/api/index.md": `---
+icon: \u{1F527}
+---
+
+# API
+
+API documentation.`,
+  "docs/api/reference.md": `# API Reference
+
+Complete API reference.`
+};
+var DocFileSystemMock = class _DocFileSystemMock extends DocFileSystem {
+  files = /* @__PURE__ */ new Map();
+  _pathSystem;
+  _basePath;
+  constructor(props) {
+    super(props);
+    this._pathSystem = props.pathSystem;
+    this._basePath = props.basePath.endsWith("/") ? props.basePath.slice(0, -1) : props.basePath;
+    if (!props.skipDefaultFiles) {
+      this.setupTestFiles(mockDirectoryData);
+    }
+    Object.freeze(this);
+  }
+  /**
+   * PathSystem accessor (for testing)
+   */
+  getPathSystem() {
+    return this._pathSystem;
+  }
+  /**
+   * Normalize path using basePath
+   */
+  normalizePath(filePath) {
+    if (filePath.startsWith(this._basePath)) {
+      return filePath;
+    }
+    const cleanPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+    return `${this._basePath}/${cleanPath}`;
+  }
+  /**
+   * Create instance (mock data is automatically loaded)
+   */
+  static create(basePath = "/test") {
+    const pathSystem = new DocPathSystem();
+    return new _DocFileSystemMock({ basePath, pathSystem });
+  }
+  /**
+   * Factory method for testing
+   */
+  static createWithFiles(props) {
+    const pathSystem = new DocPathSystem();
+    const basePath = props.basePath ?? "/test";
+    const fileSystem = new _DocFileSystemMock({
+      basePath,
+      pathSystem,
+      skipDefaultFiles: true
+    });
+    if (props.fileContents) {
+      const now = /* @__PURE__ */ new Date();
+      for (const [path, content] of Object.entries(props.fileContents)) {
+        const cleanPath = path.startsWith("/") ? path.slice(1) : path;
+        const normalizedPath = path.startsWith(basePath) ? path : `${basePath}/${cleanPath}`;
+        fileSystem.files.set(normalizedPath, {
+          content,
+          modifiedTime: now,
+          createdTime: now,
+          size: new TextEncoder().encode(content).length
+        });
+      }
+    }
+    return fileSystem;
+  }
+  async readFile(filePath) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      const file = this.files.get(normalizedPath);
+      return file ? file.content : null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read file at ${filePath}`);
+    }
+  }
+  async writeFile(filePath, content) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      const now = /* @__PURE__ */ new Date();
+      const existing = this.files.get(normalizedPath);
+      this.files.set(normalizedPath, {
+        content,
+        modifiedTime: now,
+        createdTime: existing?.createdTime ?? now,
+        size: new TextEncoder().encode(content).length
+      });
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to write file at ${filePath}`);
+    }
+  }
+  async deleteFile(filePath) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      this.files.delete(normalizedPath);
+      return null;
+    } catch (error) {
+      return new Error(`Failed to delete file at ${filePath}: ${error}`);
+    }
+  }
+  async exists(filePath) {
+    const normalizedPath = this.normalizePath(filePath);
+    if (this.files.has(normalizedPath)) {
+      return true;
+    }
+    const dirPath = normalizedPath.endsWith("/") ? normalizedPath : `${normalizedPath}/`;
+    for (const path of this.files.keys()) {
+      if (path.startsWith(dirPath)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async copyFile(source, destination) {
+    try {
+      const normalizedSource = this.normalizePath(source);
+      const normalizedDest = this.normalizePath(destination);
+      const file = this.files.get(normalizedSource);
+      if (!file) {
+        return new Error(`Source file not found: ${normalizedSource}`);
+      }
+      this.files.set(normalizedDest, {
+        ...file,
+        createdTime: /* @__PURE__ */ new Date()
+      });
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to copy file from ${source} to ${destination}`);
+    }
+  }
+  async moveFile(source, destination) {
+    try {
+      const normalizedSource = this.normalizePath(source);
+      const normalizedDest = this.normalizePath(destination);
+      const file = this.files.get(normalizedSource);
+      if (!file) {
+        return new Error(`Source file not found: ${normalizedSource}`);
+      }
+      this.files.set(normalizedDest, file);
+      this.files.delete(normalizedSource);
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to move file from ${source} to ${destination}`);
+    }
+  }
+  async readDirectory(directoryPath) {
+    const dirPath = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+    const entries = /* @__PURE__ */ new Set();
+    for (const path of this.files.keys()) {
+      if (path.startsWith(dirPath)) {
+        const relativePath = path.slice(dirPath.length);
+        const firstSegment = relativePath.split("/")[0];
+        if (firstSegment) {
+          entries.add(firstSegment);
+        }
+      }
+    }
+    return Array.from(entries).sort();
+  }
+  async readDirectoryRecursive(directoryPath) {
+    const dirPath = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+    const files = [];
+    for (const path of this.files.keys()) {
+      if (path.startsWith(dirPath)) {
+        files.push(path);
+      }
+    }
+    return files.sort();
+  }
+  async readDirectoryFilePaths(directoryPath) {
+    try {
+      const normalizedDir = this.normalizePath(directoryPath);
+      const dirPath = normalizedDir.endsWith("/") ? normalizedDir : `${normalizedDir}/`;
+      const files = [];
+      for (const path of this.files.keys()) {
+        if (path.startsWith(dirPath) && !path.slice(dirPath.length).includes("/")) {
+          const relativePath = path.startsWith(`${this._basePath}/`) ? path.slice(this._basePath.length + 1) : path;
+          files.push(relativePath);
+        }
+      }
+      return files.sort();
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read directory file paths at ${directoryPath}`);
+    }
+  }
+  async createDirectory(_directoryPath) {
+    return null;
+  }
+  async deleteDirectory(directoryPath) {
+    const dirPath = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+    for (const path of this.files.keys()) {
+      if (path.startsWith(dirPath)) {
+        this.files.delete(path);
+      }
+    }
+  }
+  async getFileSize(filePath) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      const file = this.files.get(normalizedPath);
+      if (!file) {
+        return new Error(`File not found: ${normalizedPath}`);
+      }
+      return file.size;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file size at ${filePath}`);
+    }
+  }
+  async getFileModifiedTime(filePath) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      const file = this.files.get(normalizedPath);
+      if (!file) {
+        return new Error(`File not found: ${normalizedPath}`);
+      }
+      return file.modifiedTime;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file modified time at ${filePath}`);
+    }
+  }
+  async getFileCreatedTime(filePath) {
+    try {
+      const normalizedPath = this.normalizePath(filePath);
+      const file = this.files.get(normalizedPath);
+      if (!file) {
+        return new Error(`File not found: ${normalizedPath}`);
+      }
+      return file.createdTime;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file created time at ${filePath}`);
+    }
+  }
+  async isDirectory(relativePath) {
+    const normalizedPath = this.normalizePath(relativePath);
+    const dirPath = normalizedPath.endsWith("/") ? normalizedPath : `${normalizedPath}/`;
+    for (const path of this.files.keys()) {
+      if (path.startsWith(dirPath)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async isFile(relativePath) {
+    const normalizedPath = this.normalizePath(relativePath);
+    return this.files.has(normalizedPath);
+  }
+  /**
+   * Get list of entries in directory
+   */
+  async readDirectoryFileNames(directoryPath = "") {
+    try {
+      const normalizedDir = directoryPath === "" ? this._basePath : this.normalizePath(directoryPath);
+      const dirPath = normalizedDir.endsWith("/") ? normalizedDir : `${normalizedDir}/`;
+      const entries = /* @__PURE__ */ new Set();
+      for (const path of this.files.keys()) {
+        if (path.startsWith(dirPath)) {
+          const relativePath = path.slice(dirPath.length);
+          const firstSegment = relativePath.split("/")[0];
+          if (firstSegment) {
+            entries.add(firstSegment);
+          }
+        }
+      }
+      return Array.from(entries).sort();
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read directory at ${directoryPath}`);
+    }
+  }
+  /**
+   * Check if directory exists
+   */
+  async directoryExists(relativePath) {
+    return this.isDirectory(relativePath);
+  }
+  /**
+   * Check if file exists
+   */
+  async fileExists(relativePath) {
+    return this.isFile(relativePath);
+  }
+  /**
+   * Create directory if it doesn't exist
+   */
+  async ensureDirectoryExists(_relativePath) {
+    return null;
+  }
+  /**
+   * Clear all files
+   */
+  clear() {
+    this.files.clear();
+  }
+  /**
+   * Check file existence (for testing)
+   */
+  hasFile(filePath) {
+    const normalizedPath = this.normalizePath(filePath);
+    return this.files.has(normalizedPath);
+  }
+  /**
+   * Get file content (sync version, for testing)
+   */
+  getFileContent(filePath) {
+    const normalizedPath = this.normalizePath(filePath);
+    return this.files.get(normalizedPath)?.content;
+  }
+  /**
+   * Get all file paths (for testing)
+   */
+  getAllFilePaths() {
+    return Array.from(this.files.keys()).map((path) => {
+      return path.startsWith(`${this._basePath}/`) ? path.slice(this._basePath.length + 1) : path;
+    }).sort();
+  }
+  /**
+   * Get file count (for testing)
+   */
+  getFileCount() {
+    return this.files.size;
+  }
+  /**
+   * Setup test data
+   */
+  setupTestFiles(files) {
+    const now = /* @__PURE__ */ new Date();
+    for (const [path, content] of Object.entries(files)) {
+      const normalizedPath = this.normalizePath(path);
+      this.files.set(normalizedPath, {
+        content,
+        modifiedTime: now,
+        createdTime: now,
+        size: new TextEncoder().encode(content).length
+      });
+    }
+  }
+};
+export {
+  DocFileSystemMock
+};