@interactive-inc/docs-client 1.0.19 → 1.0.20

package/build/index.js

@@ -5138,9 +5138,9 @@ var DocClient = class {
   }
 };
 
-// lib/doc-file-system.ts
+// lib/doc-file-system-read.ts
 import * as fs from "fs/promises";
-var DocFileSystem = class {
+var DocFileSystemRead = class {
   basePath;
   pathSystem;
   constructor(props) {
@@ -5160,32 +5160,6 @@ var DocFileSystem = class {
       return error instanceof Error ? error : new Error(`Failed to read file at ${relativePath}`);
     }
   }
-  /**
-   * 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 fs.mkdir(dirPath, { recursive: true });
-      await fs.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 fs.unlink(fullPath);
-      return null;
-    } catch (error) {
-      return new Error(`Failed to delete file at ${relativePath}: ${error}`);
-    }
-  }
   /**
    * Get file name from path
    */
@@ -5289,27 +5263,90 @@ var DocFileSystem = class {
     return this.pathSystem.join(this.basePath, relativePath);
   }
   /**
-   * Create directory
+   * Get file size in bytes
    */
-  async createDirectory(relativePath) {
+  async getFileSize(relativePath) {
     try {
       const fullPath = this.pathSystem.join(this.basePath, relativePath);
-      await fs.mkdir(fullPath, { recursive: true });
-      return null;
+      const stats = await fs.stat(fullPath);
+      return stats.size;
     } catch (error) {
-      return error instanceof Error ? error : new Error(`Failed to create directory at ${relativePath}`);
+      return error instanceof Error ? error : new Error(`Failed to get file size at ${relativePath}`);
     }
   }
   /**
-   * Get file size in bytes
+   * Get file last modified time
    */
-  async getFileSize(relativePath) {
+  async getFileModifiedTime(relativePath) {
     try {
       const fullPath = this.pathSystem.join(this.basePath, relativePath);
       const stats = await fs.stat(fullPath);
-      return stats.size;
+      return stats.mtime;
     } catch (error) {
-      return error instanceof Error ? error : new Error(`Failed to get file size at ${relativePath}`);
+      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/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}`);
     }
   }
   /**
@@ -5317,12 +5354,16 @@ var DocFileSystem = class {
    */
   async ensureDirectoryExists(relativePath) {
     try {
-      if (!await this.exists(relativePath)) {
-        const result = await this.createDirectory(relativePath);
-        if (result instanceof Error) {
-          return result;
+      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}`);
@@ -5335,7 +5376,7 @@ var DocFileSystem = class {
     try {
       const sourceFullPath = this.pathSystem.join(this.basePath, sourcePath);
       const destFullPath = this.pathSystem.join(this.basePath, destinationPath);
-      await fs.copyFile(sourceFullPath, destFullPath);
+      await fs2.copyFile(sourceFullPath, destFullPath);
       return null;
     } catch (error) {
       return error instanceof Error ? error : new Error(
@@ -5350,7 +5391,7 @@ var DocFileSystem = class {
     try {
       const sourceFullPath = this.pathSystem.join(this.basePath, sourcePath);
       const destFullPath = this.pathSystem.join(this.basePath, destinationPath);
-      await fs.rename(sourceFullPath, destFullPath);
+      await fs2.rename(sourceFullPath, destFullPath);
       return null;
     } catch (error) {
       return error instanceof Error ? error : new Error(
@@ -5358,151 +5399,783 @@ var DocFileSystem = class {
       );
     }
   }
+};
+
+// lib/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
+    });
+  }
   /**
-   * Get file last modified time
+   * Read file content at the specified path
    */
-  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}`);
-    }
+  async readFile(relativePath) {
+    return this.reader.readFile(relativePath);
   }
   /**
-   * Get file creation time
+   * Write content to file at the specified path (creates directory if needed)
    */
-  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}`);
-    }
+  async writeFile(relativePath, content) {
+    return this.writer.writeFile(relativePath, content);
   }
-};
-
-// lib/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);
+  /**
+   * Delete file at the specified path
+   */
+  async deleteFile(relativePath) {
+    return this.writer.deleteFile(relativePath);
   }
   /**
-   * PathSystem accessor (for testing)
+   * Get file name from path
    */
-  getPathSystem() {
-    return this._pathSystem;
+  readFileName(relativePath) {
+    return this.reader.readFileName(relativePath);
   }
   /**
-   * Normalize path using basePath
+   * Get file extension from path
    */
-  normalizePath(filePath) {
-    if (filePath.startsWith(this._basePath)) {
-      return filePath;
-    }
-    const cleanPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
-    return `${this._basePath}/${cleanPath}`;
+  readFileExtension(relativePath) {
+    return this.reader.readFileExtension(relativePath);
   }
   /**
-   * Create instance (mock data is automatically loaded)
+   * Get directory path where the file exists
    */
-  static create(basePath = "/test") {
-    const pathSystem = new DocPathSystem();
-    return new _DocFileSystemMock({ basePath, pathSystem });
+  readFileDirectory(relativePath) {
+    return this.reader.readFileDirectory(relativePath);
   }
   /**
-   * Factory method for testing
+   * Get list of entries in directory
    */
-  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 readDirectoryFileNames(relativePath = "") {
+    return this.reader.readDirectoryFileNames(relativePath);
   }
-  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 readDirectoryFilePaths(relativePath) {
+    return this.reader.readDirectoryFilePaths(relativePath);
   }
-  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}`);
-    }
+  /**
+   * 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/doc-file-system-json.ts
+import { z as z4 } from "zod";
+
+// lib/doc-file-system-json-read.ts
+import { z as z2 } from "zod";
+var zJsonDocumentData = z2.record(z2.string(), z2.string());
+function parseJsonDocumentData(data) {
+  try {
+    return zJsonDocumentData.parse(data);
+  } catch (error) {
+    return error instanceof Error ? error : new Error("Failed to parse JSON document data");
+  }
+}
+var DocFileSystemJsonRead = class {
+  data;
+  basePath;
+  pathSystem;
+  constructor(props) {
+    const parsed = parseJsonDocumentData(props.data);
+    if (parsed instanceof Error) {
+      throw parsed;
+    }
+    this.data = parsed;
+    this.basePath = props.basePath ?? "json://";
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    Object.freeze(this);
+  }
+  /**
+   * Read file content from JSON data
+   */
+  async readFile(relativePath) {
+    try {
+      const normalizedPath = this.normalizePath(relativePath);
+      const content = this.data[normalizedPath];
+      return content ?? null;
+    } 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 file names in directory
+   */
+  async readDirectoryFileNames(relativePath = "") {
+    try {
+      const normalizedDir = this.normalizePath(relativePath);
+      const fileNames = /* @__PURE__ */ new Set();
+      for (const filePath of Object.keys(this.data)) {
+        if (this.isFileInDirectory(filePath, normalizedDir)) {
+          const relativePart = this.getRelativePartFromDirectory(
+            filePath,
+            normalizedDir
+          );
+          const segments = relativePart.split("/").filter(Boolean);
+          if (segments.length > 0) {
+            fileNames.add(segments[0]);
+          }
+        }
+      }
+      return Array.from(fileNames).sort();
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to read directory at ${relativePath}`);
+    }
+  }
+  /**
+   * Get list of file paths in directory
+   */
+  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 normalizedPath = this.normalizePath(relativePath);
+      for (const filePath of Object.keys(this.data)) {
+        if (filePath.startsWith(`${normalizedPath}/`)) {
+          return true;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if path is a file
+   */
+  async isFile(relativePath) {
+    try {
+      const normalizedPath = this.normalizePath(relativePath);
+      return normalizedPath in this.data;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if file or directory exists
+   */
+  async exists(relativePath) {
+    const isFile = await this.isFile(relativePath);
+    if (isFile) return true;
+    const isDir = await this.isDirectory(relativePath);
+    return isDir;
+  }
+  /**
+   * 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 content = await this.readFile(relativePath);
+      if (content instanceof Error) {
+        return content;
+      }
+      if (content === null) {
+        return new Error(`File not found: ${relativePath}`);
+      }
+      return Buffer.byteLength(content, "utf8");
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file size at ${relativePath}`);
+    }
+  }
+  /**
+   * Get file last modified time (not available for JSON data)
+   */
+  async getFileModifiedTime(_relativePath) {
+    return new Error("File modified time not available for JSON data");
+  }
+  /**
+   * Get file creation time (not available for JSON data)
+   */
+  async getFileCreatedTime(_relativePath) {
+    return new Error("File creation time not available for JSON data");
+  }
+  /**
+   * Get all file paths in the JSON data
+   */
+  getAllFilePaths() {
+    return Object.keys(this.data);
+  }
+  /**
+   * Get the raw JSON data
+   */
+  getRawData() {
+    return { ...this.data };
+  }
+  /**
+   * Normalize path by removing leading/trailing slashes
+   */
+  normalizePath(path) {
+    return path.replace(/^\/+|\/+$/g, "");
+  }
+  /**
+   * Check if a file path is within a directory
+   */
+  isFileInDirectory(filePath, dirPath) {
+    if (dirPath === "") {
+      return true;
+    }
+    return filePath.startsWith(`${dirPath}/`) || filePath === dirPath;
+  }
+  /**
+   * Get the relative part of a file path from a directory
+   */
+  getRelativePartFromDirectory(filePath, dirPath) {
+    if (dirPath === "") {
+      return filePath;
+    }
+    if (filePath.startsWith(`${dirPath}/`)) {
+      return filePath.slice(dirPath.length + 1);
+    }
+    return "";
+  }
+};
+
+// lib/doc-file-system-json-write.ts
+import { z as z3 } from "zod";
+var zJsonDocumentData2 = z3.record(z3.string(), z3.string());
+function parseJsonDocumentData2(data) {
+  try {
+    return zJsonDocumentData2.parse(data);
+  } catch (error) {
+    return error instanceof Error ? error : new Error("Failed to parse JSON document data");
+  }
+}
+var DocFileSystemJsonWrite = class {
+  data;
+  basePath;
+  pathSystem;
+  reader;
+  onDataChange;
+  constructor(props = {}) {
+    if (props.data !== void 0) {
+      const parsed = parseJsonDocumentData2(props.data);
+      if (parsed instanceof Error) {
+        throw parsed;
+      }
+      this.data = parsed;
+    } else {
+      this.data = {};
+    }
+    this.basePath = props.basePath ?? "json://";
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    this.reader = props.reader;
+    this.onDataChange = props.onDataChange;
+  }
+  /**
+   * Write content to JSON data
+   */
+  async writeFile(relativePath, content) {
+    try {
+      const normalizedPath = this.normalizePath(relativePath);
+      this.data[normalizedPath] = content;
+      this.notifyDataChange();
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to write file at ${relativePath}`);
+    }
+  }
+  /**
+   * Delete file from JSON data
+   */
+  async deleteFile(relativePath) {
+    try {
+      const normalizedPath = this.normalizePath(relativePath);
+      if (!(normalizedPath in this.data)) {
+        return new Error(`File not found: ${relativePath}`);
+      }
+      delete this.data[normalizedPath];
+      this.notifyDataChange();
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to delete file at ${relativePath}`);
+    }
+  }
+  /**
+   * Create directory (creates a placeholder entry)
+   */
+  async createDirectory(relativePath) {
+    try {
+      const normalizedPath = this.normalizePath(relativePath);
+      const gitkeepPath = this.pathSystem.join(normalizedPath, ".gitkeep");
+      const normalizedGitkeepPath = this.normalizePath(gitkeepPath);
+      this.data[normalizedGitkeepPath] = "";
+      this.notifyDataChange();
+      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;
+        }
+      } else {
+        if (await this.directoryExistsInData(relativePath)) {
+          return null;
+        }
+      }
+      return await this.createDirectory(relativePath);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to ensure directory exists at ${relativePath}`);
+    }
+  }
+  /**
+   * Copy file within JSON data
+   */
+  async copyFile(sourcePath, destinationPath) {
+    try {
+      const normalizedSourcePath = this.normalizePath(sourcePath);
+      const normalizedDestPath = this.normalizePath(destinationPath);
+      if (this.reader) {
+        const content = await this.reader.readFile(sourcePath);
+        if (content instanceof Error) {
+          return content;
+        }
+        if (content === null) {
+          return new Error(`Source file not found: ${sourcePath}`);
+        }
+        this.data[normalizedDestPath] = content;
+      } else {
+        if (!(normalizedSourcePath in this.data)) {
+          return new Error(`Source file not found: ${sourcePath}`);
+        }
+        this.data[normalizedDestPath] = this.data[normalizedSourcePath];
+      }
+      this.notifyDataChange();
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(
+        `Failed to copy file from ${sourcePath} to ${destinationPath}`
+      );
+    }
+  }
+  /**
+   * Move file within JSON data
+   */
+  async moveFile(sourcePath, destinationPath) {
+    try {
+      const copyResult = await this.copyFile(sourcePath, destinationPath);
+      if (copyResult !== null) {
+        return copyResult;
+      }
+      return await this.deleteFile(sourcePath);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(
+        `Failed to move file from ${sourcePath} to ${destinationPath}`
+      );
+    }
+  }
+  /**
+   * Get the current JSON data
+   */
+  getData() {
+    return { ...this.data };
+  }
+  /**
+   * Update the entire JSON data
+   */
+  setData(data) {
+    try {
+      const parsed = parseJsonDocumentData2(data);
+      if (parsed instanceof Error) {
+        return parsed;
+      }
+      this.data = parsed;
+      this.notifyDataChange();
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error("Failed to set JSON data");
+    }
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.data = {};
+    this.notifyDataChange();
+  }
+  /**
+   * Get all file paths in the JSON data
+   */
+  getAllFilePaths() {
+    return Object.keys(this.data);
+  }
+  /**
+   * Normalize path by removing leading/trailing slashes
+   */
+  normalizePath(path) {
+    return path.replace(/^\/+|\/+$/g, "");
+  }
+  /**
+   * Check if directory exists in data
+   */
+  async directoryExistsInData(relativePath) {
+    const normalizedPath = this.normalizePath(relativePath);
+    for (const filePath of Object.keys(this.data)) {
+      if (filePath.startsWith(`${normalizedPath}/`)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Notify data change callback
+   */
+  notifyDataChange() {
+    if (this.onDataChange) {
+      this.onDataChange({ ...this.data });
+    }
+  }
+};
+
+// lib/doc-file-system-json.ts
+var zJsonDocumentData3 = z4.record(z4.string(), z4.string());
+var DocFileSystemJson = class _DocFileSystemJson extends DocFileSystem {
+  jsonReader;
+  jsonWriter;
+  constructor(props = {}) {
+    const reader = new DocFileSystemJsonRead({
+      data: props.data,
+      basePath: props.basePath,
+      pathSystem: props.pathSystem
+    });
+    const writer = new DocFileSystemJsonWrite({
+      data: props.data,
+      basePath: props.basePath,
+      pathSystem: props.pathSystem,
+      reader,
+      onDataChange: props.onDataChange
+    });
+    super({
+      basePath: props.basePath ?? "json://",
+      pathSystem: props.pathSystem,
+      reader,
+      writer
+    });
+    this.jsonReader = reader;
+    this.jsonWriter = writer;
+    Object.freeze(this);
+  }
+  /**
+   * Get the current JSON data
+   */
+  getData() {
+    return this.jsonWriter.getData();
+  }
+  /**
+   * Update the entire JSON data
+   */
+  setData(data) {
+    return this.jsonWriter.setData(data);
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.jsonWriter.clear();
+  }
+  /**
+   * Get all file paths in the JSON data
+   */
+  getAllFilePaths() {
+    return this.jsonReader.getAllFilePaths();
+  }
+  /**
+   * Get the raw JSON data (read-only copy)
+   */
+  getRawData() {
+    return this.jsonReader.getRawData();
+  }
+  /**
+   * Create from docs-to-json format
+   */
+  static fromDocsToJson(data, options = {}) {
+    return new _DocFileSystemJson({
+      ...options,
+      data
+    });
+  }
+  /**
+   * Export to docs-to-json format
+   */
+  toDocsToJson() {
+    return this.getData();
+  }
+};
+
+// lib/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 {
@@ -5621,64 +6294,288 @@ var DocFileSystemMock = class _DocFileSystemMock extends DocFileSystem {
       return error instanceof Error ? error : new Error(`Failed to get file size at ${filePath}`);
     }
   }
-  async getFileModifiedTime(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
+      });
+    }
+  }
+};
+
+// lib/doc-file-system-octokit-read.ts
+import { Octokit } from "@octokit/rest";
+var DocFileSystemOctokitRead = class {
+  octokit;
+  owner;
+  repo;
+  branch;
+  pathSystem;
+  basePath;
+  fileCache = /* @__PURE__ */ new Map();
+  constructor(props) {
+    this.owner = props.owner;
+    this.repo = props.repo;
+    this.branch = props.branch ?? "main";
+    this.basePath = props.basePath;
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    this.octokit = new Octokit({ auth: props.token });
+    Object.freeze(this);
+  }
+  /**
+   * Read file content from GitHub repository
+   */
+  async readFile(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const response = await this.octokit.repos.getContent({
+        owner: this.owner,
+        repo: this.repo,
+        path: fullPath,
+        ref: this.branch
+      });
+      if ("type" in response.data && response.data.type === "file") {
+        const content = Buffer.from(response.data.content, "base64").toString(
+          "utf-8"
+        );
+        this.fileCache.set(fullPath, {
+          sha: response.data.sha,
+          content,
+          size: response.data.size
+        });
+        return content;
+      }
+      return new Error(`Path ${relativePath} is not a file`);
+    } catch (error) {
+      if (error && typeof error === "object" && "status" in error && error.status === 404) {
+        return null;
+      }
+      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 file names in directory
+   */
+  async readDirectoryFileNames(relativePath = "") {
     try {
-      const normalizedPath = this.normalizePath(filePath);
-      const file = this.files.get(normalizedPath);
-      if (!file) {
-        return new Error(`File not found: ${normalizedPath}`);
+      const fullPath = relativePath ? this.pathSystem.join(this.basePath, relativePath) : this.basePath;
+      const response = await this.octokit.repos.getContent({
+        owner: this.owner,
+        repo: this.repo,
+        path: fullPath,
+        ref: this.branch
+      });
+      if (Array.isArray(response.data)) {
+        return response.data.map((item) => item.name);
       }
-      return file.modifiedTime;
+      return new Error(`Path ${relativePath} is not a directory`);
     } catch (error) {
-      return error instanceof Error ? error : new Error(`Failed to get file modified time at ${filePath}`);
+      return error instanceof Error ? error : new Error(`Failed to read directory at ${relativePath}`);
     }
   }
-  async getFileCreatedTime(filePath) {
+  /**
+   * Get list of file paths in directory
+   */
+  async readDirectoryFilePaths(relativePath) {
     try {
-      const normalizedPath = this.normalizePath(filePath);
-      const file = this.files.get(normalizedPath);
-      if (!file) {
-        return new Error(`File not found: ${normalizedPath}`);
+      const fileNames = await this.readDirectoryFileNames(relativePath);
+      if (fileNames instanceof Error) {
+        return fileNames;
       }
-      return file.createdTime;
+      return fileNames.map(
+        (fileName) => this.pathSystem.join(relativePath, fileName)
+      );
     } catch (error) {
-      return error instanceof Error ? error : new Error(`Failed to get file created time at ${filePath}`);
+      return error instanceof Error ? error : new Error(`Failed to read directory file paths at ${relativePath}`);
     }
   }
+  /**
+   * Check if path is a directory
+   */
   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;
-      }
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const response = await this.octokit.repos.getContent({
+        owner: this.owner,
+        repo: this.repo,
+        path: fullPath,
+        ref: this.branch
+      });
+      return Array.isArray(response.data);
+    } catch {
+      return false;
     }
-    return false;
   }
+  /**
+   * Check if path is a file
+   */
   async isFile(relativePath) {
-    const normalizedPath = this.normalizePath(relativePath);
-    return this.files.has(normalizedPath);
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const response = await this.octokit.repos.getContent({
+        owner: this.owner,
+        repo: this.repo,
+        path: fullPath,
+        ref: this.branch
+      });
+      return !Array.isArray(response.data) && response.data.type === "file";
+    } catch {
+      return false;
+    }
   }
   /**
-   * Get list of entries in directory
+   * Check if file or directory exists
    */
-  async readDirectoryFileNames(directoryPath = "") {
+  async exists(relativePath) {
     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}`);
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      await this.octokit.repos.getContent({
+        owner: this.owner,
+        repo: this.repo,
+        path: fullPath,
+        ref: this.branch
+      });
+      return true;
+    } catch {
+      return false;
     }
   }
   /**
@@ -5694,62 +6591,303 @@ var DocFileSystemMock = class _DocFileSystemMock extends DocFileSystem {
     return this.isFile(relativePath);
   }
   /**
-   * Create directory if it doesn't exist
+   * Get base path
    */
-  async ensureDirectoryExists(_relativePath) {
-    return null;
+  getBasePath() {
+    return this.basePath;
   }
   /**
-   * Clear all files
+   * Convert relative path to absolute path
    */
-  clear() {
-    this.files.clear();
+  resolve(relativePath) {
+    return this.pathSystem.join(this.basePath, relativePath);
   }
   /**
-   * Check file existence (for testing)
+   * Get file size in bytes
    */
-  hasFile(filePath) {
-    const normalizedPath = this.normalizePath(filePath);
-    return this.files.has(normalizedPath);
+  async getFileSize(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const cached = this.fileCache.get(fullPath);
+      if (cached) {
+        return cached.size;
+      }
+      const response = await this.octokit.repos.getContent({
+        owner: this.owner,
+        repo: this.repo,
+        path: fullPath,
+        ref: this.branch
+      });
+      if ("size" in response.data) {
+        return response.data.size;
+      }
+      return new Error(`Cannot get size for ${relativePath}`);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file size at ${relativePath}`);
+    }
   }
   /**
-   * Get file content (sync version, for testing)
+   * Get file last modified time
    */
-  getFileContent(filePath) {
-    const normalizedPath = this.normalizePath(filePath);
-    return this.files.get(normalizedPath)?.content;
+  async getFileModifiedTime(relativePath) {
+    try {
+      const commits = await this.octokit.repos.listCommits({
+        owner: this.owner,
+        repo: this.repo,
+        path: relativePath,
+        sha: this.branch,
+        per_page: 1
+      });
+      if (commits.data.length > 0 && commits.data[0].commit.author?.date) {
+        return new Date(commits.data[0].commit.author.date);
+      }
+      return new Error(`No commits found for ${relativePath}`);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file modified time at ${relativePath}`);
+    }
   }
   /**
-   * Get all file paths (for testing)
+   * Get file creation time (first commit)
    */
-  getAllFilePaths() {
-    return Array.from(this.files.keys()).map((path) => {
-      return path.startsWith(`${this._basePath}/`) ? path.slice(this._basePath.length + 1) : path;
-    }).sort();
+  async getFileCreatedTime(relativePath) {
+    try {
+      const commits = await this.octokit.repos.listCommits({
+        owner: this.owner,
+        repo: this.repo,
+        path: relativePath,
+        sha: this.branch
+      });
+      const lastCommit = commits.data[commits.data.length - 1];
+      if (lastCommit?.commit.author?.date) {
+        return new Date(lastCommit.commit.author.date);
+      }
+      return new Error(`No commits found for ${relativePath}`);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to get file created time at ${relativePath}`);
+    }
   }
   /**
-   * Get file count (for testing)
+   * Get cached SHA for a file
    */
-  getFileCount() {
-    return this.files.size;
+  getCachedSha(relativePath) {
+    const fullPath = this.pathSystem.join(this.basePath, relativePath);
+    return this.fileCache.get(fullPath)?.sha;
+  }
+};
+
+// lib/doc-file-system-octokit-write.ts
+import { Octokit as Octokit2 } from "@octokit/rest";
+var DocFileSystemOctokitWrite = class {
+  octokit;
+  owner;
+  repo;
+  basePath;
+  branch;
+  pathSystem;
+  reader;
+  constructor(props) {
+    this.owner = props.owner;
+    this.repo = props.repo;
+    this.basePath = props.basePath;
+    this.branch = props.branch ?? "main";
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    this.octokit = new Octokit2({ auth: props.token });
+    this.reader = props.reader;
+    Object.freeze(this);
   }
   /**
-   * Setup test data
+   * Write content to file in GitHub repository
    */
-  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
+  async writeFile(relativePath, content) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      const encodedContent = Buffer.from(content).toString("base64");
+      let sha;
+      if (this.reader && "getCachedSha" in this.reader) {
+        sha = this.reader.getCachedSha(
+          relativePath
+        );
+      }
+      if (!sha) {
+        try {
+          const existing = await this.octokit.repos.getContent({
+            owner: this.owner,
+            repo: this.repo,
+            path: fullPath,
+            ref: this.branch
+          });
+          if ("sha" in existing.data) {
+            sha = existing.data.sha;
+          }
+        } catch {
+        }
+      }
+      await this.octokit.repos.createOrUpdateFileContents({
+        owner: this.owner,
+        repo: this.repo,
+        path: fullPath,
+        message: `Update ${fullPath}`,
+        content: encodedContent,
+        branch: this.branch,
+        sha
+      });
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to write file at ${relativePath}`);
+    }
+  }
+  /**
+   * Delete file from GitHub repository
+   */
+  async deleteFile(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      let sha;
+      if (this.reader && "getCachedSha" in this.reader) {
+        sha = this.reader.getCachedSha(
+          relativePath
+        );
+      }
+      if (!sha) {
+        const existing = await this.octokit.repos.getContent({
+          owner: this.owner,
+          repo: this.repo,
+          path: fullPath,
+          ref: this.branch
+        });
+        if ("sha" in existing.data) {
+          sha = existing.data.sha;
+        }
+      }
+      if (!sha) {
+        return new Error(`Cannot delete file at ${relativePath}: SHA not found`);
+      }
+      await this.octokit.repos.deleteFile({
+        owner: this.owner,
+        repo: this.repo,
+        path: fullPath,
+        message: `Delete ${fullPath}`,
+        sha,
+        branch: this.branch
       });
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to delete file at ${relativePath}`);
+    }
+  }
+  /**
+   * Create directory by creating a .gitkeep file
+   */
+  async createDirectory(relativePath) {
+    try {
+      const gitkeepPath = this.pathSystem.join(relativePath, ".gitkeep");
+      return await this.writeFile(gitkeepPath, "");
+    } 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;
+        }
+      }
+      return await this.createDirectory(relativePath);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(`Failed to ensure directory exists at ${relativePath}`);
+    }
+  }
+  /**
+   * Copy file to new location
+   */
+  async copyFile(sourcePath, destinationPath) {
+    try {
+      if (!this.reader) {
+        return new Error("Reader is required for copy operation");
+      }
+      const content = await this.reader.readFile(sourcePath);
+      if (content instanceof Error) {
+        return content;
+      }
+      if (content === null) {
+        return new Error(`Source file ${sourcePath} does not exist`);
+      }
+      return await this.writeFile(destinationPath, content);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(
+        `Failed to copy file from ${sourcePath} to ${destinationPath}`
+      );
+    }
+  }
+  /**
+   * Move file to new location
+   */
+  async moveFile(sourcePath, destinationPath) {
+    try {
+      const copyResult = await this.copyFile(sourcePath, destinationPath);
+      if (copyResult !== null) {
+        return copyResult;
+      }
+      return await this.deleteFile(sourcePath);
+    } catch (error) {
+      return error instanceof Error ? error : new Error(
+        `Failed to move file from ${sourcePath} to ${destinationPath}`
+      );
     }
   }
 };
 
+// lib/doc-file-system-octokit.ts
+var DocFileSystemOctokit = class extends DocFileSystem {
+  owner;
+  repo;
+  branch;
+  constructor(props) {
+    const reader = new DocFileSystemOctokitRead({
+      owner: props.owner,
+      repo: props.repo,
+      basePath: props.basePath,
+      branch: props.branch,
+      token: props.token,
+      pathSystem: props.pathSystem
+    });
+    const writer = new DocFileSystemOctokitWrite({
+      owner: props.owner,
+      repo: props.repo,
+      basePath: props.basePath,
+      branch: props.branch,
+      token: props.token,
+      pathSystem: props.pathSystem,
+      reader
+    });
+    super({
+      basePath: props.basePath,
+      pathSystem: props.pathSystem,
+      reader,
+      writer
+    });
+    this.owner = props.owner;
+    this.repo = props.repo;
+    this.branch = props.branch ?? "main";
+    Object.freeze(this);
+  }
+  /**
+   * Get repository information
+   */
+  getRepositoryInfo() {
+    return {
+      owner: this.owner,
+      repo: this.repo,
+      branch: this.branch
+    };
+  }
+};
+
 // lib/doc-path-system-mock.ts
 var DocPathSystemMock = class _DocPathSystemMock extends DocPathSystem {
   _separator;
@@ -6390,7 +7528,15 @@ export {
   DocFilePathValue,
   DocFileRelationReference,
   DocFileSystem,
+  DocFileSystemJson,
+  DocFileSystemJsonRead,
+  DocFileSystemJsonWrite,
   DocFileSystemMock,
+  DocFileSystemOctokit,
+  DocFileSystemOctokitRead,
+  DocFileSystemOctokitWrite,
+  DocFileSystemRead,
+  DocFileSystemWrite,
   DocFileTreeSystem,
   DocFileUnknownEntity,
   DocFileUnknownReference,