@interactive-inc/docs-client 1.0.20 → 1.1.1

package/build/file-system-octokit.js

@@ -0,0 +1,715 @@
+import { Octokit } from '@octokit/rest';
+
+// 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.ts
+var DocFileSystem = class {
+  reader;
+  writer;
+  basePath;
+  pathSystem;
+  constructor(props) {
+    this.basePath = props.basePath;
+    this.pathSystem = props.pathSystem ?? new DocPathSystem();
+    this.reader = props.reader;
+    this.writer = props.writer;
+  }
+  /**
+   * 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 createEmptyDirectory(relativePath) {
+    return this.writer.createEmptyDirectory(relativePath);
+  }
+  /**
+   * Get file size in bytes
+   */
+  async getFileSize(relativePath) {
+    return this.reader.getFileSize(relativePath);
+  }
+  /**
+   * Create directory if it doesn't exist
+   */
+  async createDirectory(relativePath) {
+    return this.writer.createDirectory(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 getFileUpdatedTime(relativePath) {
+    return this.reader.getFileUpdatedTime(relativePath);
+  }
+  /**
+   * Get file creation time
+   */
+  async getFileCreatedTime(relativePath) {
+    return this.reader.getFileCreatedTime(relativePath);
+  }
+};
+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 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 new Error(`Path ${relativePath} is not a directory`);
+    } 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 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;
+    }
+  }
+  /**
+   * Check if path is a file
+   */
+  async isFile(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
+      });
+      return !Array.isArray(response.data) && response.data.type === "file";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if file or directory exists
+   */
+  async exists(relativePath) {
+    try {
+      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;
+    }
+  }
+  /**
+   * 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 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 last modified time
+   */
+  async getFileUpdatedTime(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 file creation time (first commit)
+   */
+  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 cached SHA for a file
+   */
+  getCachedSha(relativePath) {
+    const fullPath = this.pathSystem.join(this.basePath, relativePath);
+    return this.fileCache.get(fullPath)?.sha;
+  }
+};
+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 Octokit({ auth: props.token });
+    this.reader = props.reader;
+    Object.freeze(this);
+  }
+  /**
+   * Write content to file in GitHub repository
+   */
+  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 createEmptyDirectory(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 createDirectory(relativePath) {
+    try {
+      if (this.reader) {
+        const exists = await this.reader.exists(relativePath);
+        if (exists) {
+          return null;
+        }
+      }
+      return await this.createEmptyDirectory(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/modules/file-system/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);
+  }
+};
+
+export { DocFileSystemOctokit, DocFileSystemOctokitRead, DocFileSystemOctokitWrite };