@interactive-inc/docs-client 1.0.20 → 1.1.1

package/build/file-system-node.js

@@ -0,0 +1,544 @@
+import * as fs from 'fs/promises';
+
+// 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 DocFileSystemNodeRead = 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 getFileUpdatedTime(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}`);
+    }
+  }
+};
+var DocFileSystemNodeWrite = 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 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}`);
+    }
+  }
+  /**
+   * Create directory
+   */
+  async createEmptyDirectory(relativePath) {
+    try {
+      const fullPath = this.pathSystem.join(this.basePath, relativePath);
+      await fs.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 createDirectory(relativePath) {
+    try {
+      if (this.reader) {
+        const exists = await this.reader.exists(relativePath);
+        if (exists) {
+          return null;
+        }
+      }
+      const result = await this.createEmptyDirectory(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 fs.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 fs.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-node.ts
+var DocFileSystemNode = class extends DocFileSystem {
+  constructor(props) {
+    const reader = new DocFileSystemNodeRead({
+      basePath: props.basePath,
+      pathSystem: props.pathSystem
+    });
+    const writer = new DocFileSystemNodeWrite({
+      basePath: props.basePath,
+      pathSystem: props.pathSystem,
+      reader
+    });
+    super({
+      basePath: props.basePath,
+      pathSystem: props.pathSystem,
+      reader,
+      writer
+    });
+  }
+};
+
+export { DocFileSystemNode, DocFileSystemNodeRead, DocFileSystemNodeWrite };

package/build/file-system-octokit.d.ts

@@ -0,0 +1,166 @@
+import { a as DocPathSystem } from './doc-file-system.interface-C5vpYrOL.js';
+import { D as DocFileSystem, a as DocFileSystemReadInterface, b as DocFileSystemWriteInterface } from './doc-file-system-DEmPPJPE.js';
+import { Octokit } from '@octokit/rest';
+
+type GitHubProps = {
+    owner: string;
+    repo: string;
+    basePath: string;
+    branch?: string;
+    token: string;
+    pathSystem?: DocPathSystem;
+};
+/**
+ * GitHub repository file system using Octokit with separate read/write components
+ */
+declare class DocFileSystemOctokit extends DocFileSystem {
+    readonly owner: string;
+    readonly repo: string;
+    readonly branch: string;
+    constructor(props: GitHubProps);
+}
+
+type Props$1 = {
+    owner: string;
+    repo: string;
+    basePath: string;
+    branch?: string;
+    token: string;
+    pathSystem?: DocPathSystem;
+};
+type FileCache = {
+    sha: string;
+    content: string;
+    size: number;
+    modifiedTime?: string;
+};
+/**
+ * GitHub repository read-only file system using Octokit
+ */
+declare class DocFileSystemOctokitRead implements DocFileSystemReadInterface {
+    protected readonly octokit: Octokit;
+    protected readonly owner: string;
+    protected readonly repo: string;
+    protected readonly branch: string;
+    protected readonly pathSystem: DocPathSystem;
+    protected readonly basePath: string;
+    protected fileCache: Map<string, FileCache>;
+    constructor(props: Props$1);
+    /**
+     * Read file content from GitHub repository
+     */
+    readFile(relativePath: string): Promise<string | null | Error>;
+    /**
+     * Get file name from path
+     */
+    readFileName(relativePath: string): string;
+    /**
+     * Get file extension from path
+     */
+    readFileExtension(relativePath: string): string;
+    /**
+     * Get directory path where the file exists
+     */
+    readFileDirectory(relativePath: string): string;
+    /**
+     * Get list of file names in directory
+     */
+    readDirectoryFileNames(relativePath?: string): Promise<string[] | Error>;
+    /**
+     * Get list of file paths in directory
+     */
+    readDirectoryFilePaths(relativePath: string): Promise<string[] | Error>;
+    /**
+     * Check if path is a directory
+     */
+    isDirectory(relativePath: string): Promise<boolean>;
+    /**
+     * Check if path is a file
+     */
+    isFile(relativePath: string): Promise<boolean>;
+    /**
+     * Check if file or directory exists
+     */
+    exists(relativePath: string): Promise<boolean>;
+    /**
+     * Check if directory exists
+     */
+    directoryExists(relativePath: string): Promise<boolean>;
+    /**
+     * Check if file exists
+     */
+    fileExists(relativePath: string): Promise<boolean>;
+    /**
+     * Get base path
+     */
+    getBasePath(): string;
+    /**
+     * Convert relative path to absolute path
+     */
+    resolve(relativePath: string): string;
+    /**
+     * Get file size in bytes
+     */
+    getFileSize(relativePath: string): Promise<number | Error>;
+    /**
+     * Get file last modified time
+     */
+    getFileUpdatedTime(relativePath: string): Promise<Date | Error>;
+    /**
+     * Get file creation time (first commit)
+     */
+    getFileCreatedTime(relativePath: string): Promise<Date | Error>;
+    /**
+     * Get cached SHA for a file
+     */
+    getCachedSha(relativePath: string): string | undefined;
+}
+
+type Props = {
+    owner: string;
+    repo: string;
+    basePath: string;
+    branch?: string;
+    token: string;
+    pathSystem?: DocPathSystem;
+    reader?: DocFileSystemReadInterface;
+};
+/**
+ * GitHub repository write-only file system using Octokit
+ */
+declare class DocFileSystemOctokitWrite implements DocFileSystemWriteInterface {
+    private readonly octokit;
+    private readonly owner;
+    private readonly repo;
+    private readonly basePath;
+    private readonly branch;
+    private readonly pathSystem;
+    private readonly reader?;
+    constructor(props: Props);
+    /**
+     * Write content to file in GitHub repository
+     */
+    writeFile(relativePath: string, content: string): Promise<Error | null>;
+    /**
+     * Delete file from GitHub repository
+     */
+    deleteFile(relativePath: string): Promise<Error | null>;
+    /**
+     * Create directory by creating a .gitkeep file
+     */
+    createEmptyDirectory(relativePath: string): Promise<Error | null>;
+    /**
+     * Create directory if it doesn't exist
+     */
+    createDirectory(relativePath: string): Promise<Error | null>;
+    /**
+     * Copy file to new location
+     */
+    copyFile(sourcePath: string, destinationPath: string): Promise<Error | null>;
+    /**
+     * Move file to new location
+     */
+    moveFile(sourcePath: string, destinationPath: string): Promise<Error | null>;
+}
+
+export { DocFileSystemOctokit, DocFileSystemOctokitRead, DocFileSystemOctokitWrite };