@scriptdb/storage 1.0.9 → 1.1.1

package/dist/index.mjs

@@ -0,0 +1,655 @@
+// src/index.ts
+import * as fs from "fs";
+import * as path from "path";
+import { simpleGit } from "simple-git";
+var Storage = class {
+  constructor(repoPath, gitRoot) {
+    this.repo = null;
+    this.repoPath = repoPath;
+    this.gitRoot = gitRoot || repoPath;
+  }
+  async initialize(repoPath = null) {
+    try {
+      if (repoPath) {
+        this.repoPath = repoPath;
+      }
+      if (!fs.existsSync(this.repoPath)) {
+        fs.mkdirSync(this.repoPath, { recursive: true });
+      }
+      this.repo = simpleGit(this.gitRoot);
+      if (!fs.existsSync(path.join(this.gitRoot, ".git"))) {
+        try {
+          await this.repo.init();
+          await this.setupBasicConfig();
+        } catch (error) {
+          throw new Error(`Failed to initialize git repository: ${error.message}`);
+        }
+      }
+      return this.repo;
+    } catch (error) {
+      throw new Error(`Failed to initialize repository: ${error.message}`);
+    }
+  }
+  async addFile(filePath, content) {
+    try {
+      const fullPath = path.join(this.repoPath, filePath);
+      const dir = path.dirname(fullPath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(fullPath, content);
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const gitRelativePath = path.relative(this.gitRoot, fullPath);
+      await this.repo.add(gitRelativePath);
+      return {
+        success: true,
+        message: `File ${filePath} added successfully`,
+        path: fullPath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to add file: ${error.message}`
+      };
+    }
+  }
+  async updateFile(filePath, content) {
+    try {
+      const fullPath = path.join(this.repoPath, filePath);
+      if (!fs.existsSync(fullPath)) {
+        return {
+          success: false,
+          message: `File ${filePath} does not exist`
+        };
+      }
+      fs.writeFileSync(fullPath, content);
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const gitRelativePath = path.relative(this.gitRoot, fullPath);
+      await this.repo.add(gitRelativePath);
+      return {
+        success: true,
+        message: `File ${filePath} updated successfully`,
+        path: fullPath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to update file: ${error.message}`
+      };
+    }
+  }
+  async getFile(filePath) {
+    try {
+      const fullPath = path.join(this.repoPath, filePath);
+      if (!fs.existsSync(fullPath)) {
+        return {
+          success: false,
+          message: `File ${filePath} does not exist`
+        };
+      }
+      const content = fs.readFileSync(fullPath, "utf8");
+      return {
+        success: true,
+        content,
+        path: fullPath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to read file: ${error.message}`
+      };
+    }
+  }
+  async deleteFile(filePath) {
+    try {
+      const fullPath = path.join(this.repoPath, filePath);
+      if (!fs.existsSync(fullPath)) {
+        return {
+          success: false,
+          message: `File ${filePath} does not exist`
+        };
+      }
+      fs.unlinkSync(fullPath);
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const gitRelativePath = path.relative(this.gitRoot, fullPath);
+      await this.repo.add(gitRelativePath);
+      return {
+        success: true,
+        message: `File ${filePath} deleted successfully`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to delete file: ${error.message}`
+      };
+    }
+  }
+  async commit(message) {
+    try {
+      const status = await this.getStatus();
+      if (status.staged.length === 0) {
+        return {
+          success: false,
+          message: "No staged changes to commit"
+        };
+      }
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      await this.repo.commit(message);
+      return {
+        success: true,
+        message: "Changes committed successfully"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to commit changes: ${error.message}`
+      };
+    }
+  }
+  async getStatus() {
+    try {
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const status = await this.repo.status();
+      const staged = [];
+      const unstaged = [];
+      const untracked = [];
+      status.modified.forEach((file) => {
+        unstaged.push(file);
+      });
+      status.created.forEach((file) => {
+        staged.push(file);
+      });
+      status.deleted.forEach((file) => {
+        unstaged.push(file);
+      });
+      status.renamed.forEach((file) => {
+        staged.push(file.to);
+      });
+      status.not_added.forEach((file) => {
+        untracked.push(file);
+      });
+      status.staged.forEach((file) => {
+        staged.push(file);
+      });
+      return {
+        staged,
+        unstaged,
+        untracked,
+        clean: status.isClean()
+      };
+    } catch (error) {
+      return {
+        staged: [],
+        unstaged: [],
+        untracked: [],
+        clean: false,
+        error: error.message
+      };
+    }
+  }
+  async getHistory(filePath) {
+    try {
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const log = await this.repo.log({ file: filePath });
+      return log.all.map((commit) => ({
+        hash: commit.hash.substring(0, 7),
+        message: commit.message || "",
+        date: commit.date || "",
+        author: commit.author_name || ""
+      }));
+    } catch (error) {
+      return [];
+    }
+  }
+  /**
+   * Set Git configuration values
+   * @param config - Configuration object
+   * @param scope - Configuration scope ('local', 'global', 'system')
+   * @returns Result of the operation
+   */
+  async setConfig(config, scope = "local") {
+    try {
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const results = [];
+      if (config.userName) {
+        await this.repo.raw(["config", `--${scope}`, "user.name", config.userName]);
+        results.push({ key: "user.name", value: config.userName, scope });
+      }
+      if (config.userEmail) {
+        await this.repo.raw(["config", `--${scope}`, "user.email", config.userEmail]);
+        results.push({ key: "user.email", value: config.userEmail, scope });
+      }
+      if (config.options && typeof config.options === "object") {
+        for (const [key, value] of Object.entries(config.options)) {
+          await this.repo.raw(["config", `--${scope}`, key, value]);
+          results.push({ key, value, scope });
+        }
+      }
+      return {
+        success: true,
+        message: `Configuration updated successfully`,
+        changes: results
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to set configuration: ${error.message}`
+      };
+    }
+  }
+  /**
+   * Get Git configuration value
+   * @param key - Configuration key (e.g., 'user.name')
+   * @param scope - Configuration scope ('local', 'global', 'system')
+   * @returns Result containing the configuration value
+   */
+  async getConfig(key, scope = "local") {
+    try {
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const result = await this.repo.raw(["config", `--${scope}`, "--get", key]);
+      return {
+        success: true,
+        key,
+        value: result.trim(),
+        scope
+      };
+    } catch (error) {
+      if (error.message.includes("exit code: 1")) {
+        return {
+          success: false,
+          message: `Configuration key '${key}' not found in ${scope} scope`
+        };
+      }
+      return {
+        success: false,
+        message: `Failed to get configuration for ${key}: ${error.message}`
+      };
+    }
+  }
+  /**
+   * Get all Git configuration values
+   * @param scope - Configuration scope ('local', 'global', 'system')
+   * @returns Result containing all configuration values
+   */
+  async listConfig(scope = "local") {
+    try {
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const result = await this.repo.raw(["config", `--${scope}`, "--list"]);
+      const lines = result.trim().split("\n");
+      const config = {};
+      lines.forEach((line) => {
+        const [key, value] = line.split("=");
+        if (key) {
+          config[key] = value || "";
+        }
+      });
+      return {
+        success: true,
+        scope,
+        config
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to list configuration: ${error.message}`,
+        scope
+      };
+    }
+  }
+  /**
+   * Set up a basic configuration for the repository
+   * @param userName - User name (optional, defaults to 'Sandbox Storage')
+   * @param userEmail - User email (optional, defaults to 'sandbox@example.com')
+   * @param additionalConfig - Additional configuration options (optional)
+   * @returns Result of the operation
+   */
+  async setupBasicConfig(userName = "Sandbox Storage", userEmail = "sandbox@example.com", additionalConfig = {}) {
+    const config = {
+      userName,
+      userEmail,
+      options: {
+        "core.autocrlf": "false",
+        // Important for cross-platform compatibility
+        "core.filemode": "false",
+        // Important for cross-platform compatibility
+        ...additionalConfig
+      }
+    };
+    return this.setConfig(config, "local");
+  }
+  /**
+   * Add a remote repository
+   * @param name - Remote name (e.g., 'origin')
+   * @param url - Remote repository URL
+   * @returns Result of the operation
+   */
+  async addRemote(name, url) {
+    try {
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      await this.repo.addRemote(name, url);
+      return {
+        success: true,
+        message: `Remote '${name}' added successfully`,
+        name,
+        url
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to add remote '${name}': ${error.message}`
+      };
+    }
+  }
+  /**
+   * Remove a remote repository
+   * @param name - Remote name to remove
+   * @returns Result of the operation
+   */
+  async removeRemote(name) {
+    try {
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      await this.repo.removeRemote(name);
+      return {
+        success: true,
+        message: `Remote '${name}' removed successfully`,
+        name
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to remove remote '${name}': ${error.message}`
+      };
+    }
+  }
+  /**
+   * List all remote repositories
+   * @returns Result containing the list of remotes
+   */
+  async listRemotes() {
+    try {
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const remotes = await this.repo.getRemotes(true);
+      return {
+        success: true,
+        remotes: remotes.map((remote) => ({
+          name: remote.name,
+          refs: remote.refs.fetch,
+          pushUrl: remote.refs.push
+        }))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to list remotes: ${error.message}`,
+        remotes: []
+      };
+    }
+  }
+  /**
+   * Push changes to a remote repository
+   * @param remote - Remote name (defaults to 'origin')
+   * @param branch - Branch to push (defaults to current branch)
+   * @param options - Additional options
+   * @returns Result of the operation
+   */
+  async push(remote = "origin", branch = "main", options = {}) {
+    try {
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const remotes = await this.listRemotes();
+      const remoteExists = remotes.remotes.some((r) => r.name === remote);
+      if (!remoteExists) {
+        return {
+          success: false,
+          message: `Remote '${remote}' does not exist`
+        };
+      }
+      if (!branch || branch === "current") {
+        try {
+          const status = await this.repo.status();
+          branch = status.current || "main";
+        } catch {
+          branch = "main";
+        }
+      }
+      const pushOptions = {};
+      if (options.force) {
+        pushOptions["--force"] = null;
+      }
+      if (options.setUpstream !== false) {
+        pushOptions["-u"] = null;
+      }
+      await this.repo.push(remote, branch, pushOptions);
+      return {
+        success: true,
+        message: `Successfully pushed to ${remote}/${branch}`,
+        remote,
+        branch
+      };
+    } catch (error) {
+      if (error.message.includes("could not find remote") || error.message.includes("does not appear to be a git repository")) {
+        return {
+          success: false,
+          message: `Remote '${remote}' does not exist or is not a valid git repository`
+        };
+      }
+      if (error.message.includes("authentication failed")) {
+        return {
+          success: false,
+          message: `Authentication failed. Please check your credentials.`
+        };
+      }
+      return {
+        success: false,
+        message: `Failed to push to ${remote}/${branch}: ${error.message}`
+      };
+    }
+  }
+  /**
+   * Pull changes from a remote repository
+   * @param remote - Remote name (defaults to 'origin')
+   * @param branch - Branch to pull from (defaults to current branch)
+   * @param options - Additional options
+   * @returns Result of the operation
+   */
+  async pull(remote = "origin", branch = "main", options = {}) {
+    try {
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const remotes = await this.listRemotes();
+      const remoteExists = remotes.remotes.some((r) => r.name === remote);
+      if (!remoteExists) {
+        return {
+          success: false,
+          message: `Remote '${remote}' does not exist`
+        };
+      }
+      if (!branch || branch === "current") {
+        try {
+          const status = await this.repo.status();
+          branch = status.current || "main";
+        } catch {
+          branch = "main";
+        }
+      }
+      const pullOptions = [];
+      if (options.allowUnrelatedHistories) {
+        pullOptions.push("--allow-unrelated-histories");
+      }
+      await this.repo.pull(remote, branch, pullOptions);
+      return {
+        success: true,
+        message: `Successfully pulled from ${remote}/${branch}`,
+        remote,
+        branch
+      };
+    } catch (error) {
+      if (error.message.includes("could not find remote")) {
+        return {
+          success: false,
+          message: `Remote '${remote}' does not exist`
+        };
+      }
+      if (error.message.includes("authentication failed")) {
+        return {
+          success: false,
+          message: `Authentication failed. Please check your credentials.`
+        };
+      }
+      if (error.message.includes("conflict")) {
+        return {
+          success: false,
+          message: `Merge conflict occurred. Please resolve conflicts manually.`
+        };
+      }
+      return {
+        success: false,
+        message: `Failed to pull from ${remote}/${branch}: ${error.message}`
+      };
+    }
+  }
+  /**
+   * Fetch changes from a remote repository without merging
+   * @param remote - Remote name (defaults to 'origin')
+   * @param branch - Branch to fetch (defaults to 'main')
+   * @param options - Additional options
+   * @returns Result of the operation
+   */
+  async fetch(remote = "origin", branch = "main", options = {}) {
+    try {
+      if (!this.repo) {
+        throw new Error("Repository not initialized. Call initialize() first.");
+      }
+      const remotes = await this.listRemotes();
+      const remoteExists = remotes.remotes.some((r) => r.name === remote);
+      if (!remoteExists) {
+        return {
+          success: false,
+          message: `Remote '${remote}' does not exist`
+        };
+      }
+      const fetchOptions = {};
+      if (options.prune) {
+        fetchOptions["--prune"] = null;
+      }
+      await this.repo.fetch(remote, branch, fetchOptions);
+      return {
+        success: true,
+        message: `Successfully fetched from ${remote}/${branch}`,
+        remote,
+        branch
+      };
+    } catch (error) {
+      if (error.message.includes("could not find remote")) {
+        return {
+          success: false,
+          message: `Remote '${remote}' does not exist`
+        };
+      }
+      if (error.message.includes("authentication failed")) {
+        return {
+          success: false,
+          message: `Authentication failed. Please check your credentials.`
+        };
+      }
+      return {
+        success: false,
+        message: `Failed to fetch from ${remote}/${branch}: ${error.message}`
+      };
+    }
+  }
+  /**
+   * Clone a remote repository
+   * @param url - Repository URL to clone
+   * @param targetPath - Directory to clone into (optional)
+   * @param options - Additional options
+   * @returns Result of the operation
+   */
+  async clone(url, targetPath = null, options = {}) {
+    try {
+      const clonePath = targetPath || this.repoPath;
+      const cloneOptions = {};
+      if (options.bare) {
+        cloneOptions["--bare"] = null;
+      }
+      if (options.branch) {
+        cloneOptions["--branch"] = options.branch;
+      }
+      if (options.depth) {
+        cloneOptions["--depth"] = options.depth.toString();
+      }
+      const git = simpleGit();
+      await git.clone(url, clonePath, cloneOptions);
+      if (!targetPath) {
+        this.repoPath = clonePath;
+        this.repo = simpleGit(clonePath);
+      }
+      return {
+        success: true,
+        message: `Repository cloned successfully from ${url}`,
+        url,
+        path: clonePath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to clone repository from ${url}: ${error.message}`
+      };
+    }
+  }
+  listFiles() {
+    return new Promise((resolve) => {
+      try {
+        const files = [];
+        const traverse = (dir, relativePath = "") => {
+          const items = fs.readdirSync(dir);
+          items.forEach((item) => {
+            const itemPath = path.join(dir, item);
+            const itemRelativePath = path.join(relativePath, item);
+            if (fs.statSync(itemPath).isDirectory()) {
+              traverse(itemPath, itemRelativePath);
+            } else {
+              files.push(itemRelativePath);
+            }
+          });
+        };
+        traverse(this.repoPath);
+        resolve(files.filter((file) => !file.startsWith(".git")));
+      } catch (error) {
+        resolve([]);
+      }
+    });
+  }
+};
+var index_default = Storage;
+export {
+  Storage,
+  index_default as default
+};
+//# sourceMappingURL=index.mjs.map