browser-git-ops 0.0.7 → 0.0.8

package/dist/index.js

@@ -65,9 +65,8 @@ var APIGitLib = (() => {
     const owner = segments[0] || "";
     const repo = segments[1] || "";
     if (!owner || !repo) throw new Error("invalid repository path");
-    const options = { owner, repo };
+    const options = { owner, repo, branch: branchParameter || "main" };
     if (resolvedToken) options.token = resolvedToken;
-    options.branch = branchParameter || "main";
     if (!/github\.com$/i.test(hostname)) {
       options.host = `${parsed.protocol}//${parsed.host}/api/v3`;
     }
@@ -76,14 +75,39 @@ var APIGitLib = (() => {
   function buildGitlabMeta(parsed, hostname, segments, resolvedToken, branchParameter) {
     const projectId = segments.join("/");
     if (!projectId) throw new Error("invalid repository path");
-    const options = { projectId };
+    const options = { projectId, branch: branchParameter || "main" };
     if (resolvedToken) options.token = resolvedToken;
-    options.branch = branchParameter || "main";
     if (!/gitlab\.com$/i.test(hostname)) {
       options.host = `${parsed.protocol}//${parsed.host}`;
     }
     return { type: "gitlab", opts: options };
   }
+  function buildUrlFromAdapterOptions(type, options) {
+    if (type === "github") return buildGithubUrl(options);
+    if (type === "gitlab") return buildGitlabUrl(options);
+    throw new Error(`unsupported adapter type: ${type}`);
+  }
+  function buildGithubUrl(options) {
+    const owner = options.owner || "";
+    const repo = options.repo || "";
+    if (!owner || !repo) throw new Error("owner and repo are required for github");
+    const host = options.host;
+    if (host) {
+      const baseUrl = host.replace(/\/api\/v\d+\/?$/i, "");
+      return `${baseUrl}/${owner}/${repo}`;
+    }
+    return `https://github.com/${owner}/${repo}`;
+  }
+  function buildGitlabUrl(options) {
+    const projectId = options.projectId || "";
+    if (!projectId) throw new Error("projectId is required for gitlab");
+    const host = options.host;
+    if (host) {
+      const trimmed = host.replace(/\/+$/, "");
+      return `${trimmed}/${projectId}`;
+    }
+    return `https://gitlab.com/${projectId}`;
+  }
 
   // src/virtualfs/opfsStorage.ts
   var ERR_OPFS_DIR_API = "OPFS directory API not available";
@@ -1049,6 +1073,10 @@ var APIGitLib = (() => {
   var RetryExhaustedError = class extends RetryableError {
     code = "RETRY_EXHAUSTED";
     cause;
+    /**
+     * @param {string} message error message
+     * @param {any} [cause] original cause
+     */
     constructor(message, cause) {
       super(message);
       this.name = "RetryExhaustedError";
@@ -1282,6 +1310,7 @@ var APIGitLib = (() => {
      * @param items items to map
      * @param mapper async mapper
      * @param concurrency concurrency limit
+     * @param [options] options with optional controller
      * @returns Promise resolving to mapped results
      */
     mapWithConcurrency(items, mapper, concurrency = 5, options) {
@@ -1810,6 +1839,9 @@ var APIGitLib = (() => {
     async _buildFileMapFromHead(headSha) {
       const treeResponse = await this._fetchWithRetry(`${this.baseUrl}/git/trees/${headSha}${"?recursive=1"}`, { method: "GET", headers: this.headers }, 4, 300);
       const treeJ = await treeResponse.json();
+      if (treeJ && treeJ.truncated === true) {
+        this.logWarn("GitHub tree response was truncated. Some files may be missing. Consider using non-recursive tree fetching for large repositories.");
+      }
       const files = treeJ && treeJ.tree ? treeJ.tree.filter((t) => t.type === "blob") : [];
       const shas = {};
       const fileMap = /* @__PURE__ */ new Map();
@@ -2104,6 +2136,12 @@ var APIGitLib = (() => {
         this._handleCreateBranchError(message, branchName);
       }
     }
+    /**
+     * Extract SHA from commit response text.
+     * @param {string} text response text
+     * @param {string} fallback fallback SHA value
+     * @returns {string} extracted SHA or fallback
+     */
     _extractShaFromCommitResponseText(text, fallback) {
       try {
         const data = text ? JSON.parse(text) : {};
@@ -2256,6 +2294,11 @@ var APIGitLib = (() => {
       const remote = await this._safeGetBranchHead(branch);
       return remote ?? branch;
     }
+    /**
+     * Safely fetch branch head SHA, returning null on failure.
+     * @param {string} branch branch name
+     * @returns {Promise<string|null>} head SHA or null
+     */
     async _safeGetBranchHead(branch) {
       try {
         const branchResponse = await this.fetchWithRetry(`${this.baseUrl}/repository/branches/${encodeURIComponent(branch)}`, { method: "GET", headers: this.headers });
@@ -2271,14 +2314,25 @@ var APIGitLib = (() => {
     }
     /**
      * Fetch repository tree and build shas map and fileSet.
+     * Paginates through all pages using offset-based pagination (per_page=100).
      * @param {string} branch branch name
      * @returns {Promise<{shas:Record<string,string>,fileSet:Set<string>}>}
      */
     async _fetchTreeAndBuildShas(branch) {
-      const treeResponse = await this.fetchWithRetry(`${this.baseUrl}/repository/tree?recursive=true&ref=${encodeURIComponent(branch)}`, { method: "GET", headers: this.headers });
-      const treeJ = await treeResponse.json();
-      const files = Array.isArray(treeJ) ? treeJ.filter((t) => t.type === "blob") : [];
-      return this._buildShasAndFileSet(files);
+      const allFiles = [];
+      let page = 1;
+      const perPage = 100;
+      while (true) {
+        const url = `${this.baseUrl}/repository/tree?recursive=true&ref=${encodeURIComponent(branch)}&per_page=${perPage}&page=${page}`;
+        const treeResponse = await this.fetchWithRetry(url, { method: "GET", headers: this.headers });
+        const treeJ = await treeResponse.json();
+        const entries = Array.isArray(treeJ) ? treeJ : [];
+        allFiles.push(...entries.filter((t) => t.type === "blob"));
+        const paging = this._parsePagingHeaders(treeResponse);
+        if (!paging.nextPage) break;
+        page = paging.nextPage;
+      }
+      return this._buildShasAndFileSet(allFiles);
     }
     /**
      * Fetch contents for requested paths from a FileSet with caching.
@@ -2310,6 +2364,7 @@ var APIGitLib = (() => {
      * @param {Record<string,string>} snapshot snapshot map
      * @param {string} p file path
      * @param {string} branch branch
+     * @param {AbortSignal} [signal] optional abort signal
      * @returns {Promise<string|null>} file content or null
      */
     async _fetchFileContentForPath(cache, snapshot, p, branch, signal) {
@@ -2330,6 +2385,7 @@ var APIGitLib = (() => {
      * Fetch raw file content from GitLab; return null on failure.
      * @param {string} path file path
      * @param {string} branch branch name
+     * @param {AbortSignal} [signal] optional abort signal
      * @returns {Promise<string|null>} file content or null
      */
     async _fetchFileRaw(path, branch, signal) {
@@ -2395,6 +2451,12 @@ var APIGitLib = (() => {
       }
       return null;
     }
+    /**
+     * Try running a single resolver, returning null on failure.
+     * @param {Function} r resolver function
+     * @param {string} reference commit-ish to resolve
+     * @returns {Promise<string|null>} resolved sha or null
+     */
     async _tryRunResolver(r, reference) {
       try {
         return await r(reference);
@@ -3732,47 +3794,111 @@ var APIGitLib = (() => {
      * Set adapter instance and persist adapter metadata into index file.
      * Supports overloads:
      * - setAdapter(meta: AdapterMeta)
-     * - setAdapter(type: string, url: string, token?: string)
-     * - setAdapter(url: string)
-    * @param {AdapterMeta|string} metaOrTypeOrUrl
+     * - setAdapter(type: string, url: string, branch?: string, token?: string)
+     * - setAdapter(url: string, branch?: string, token?: string)
+     * @param {AdapterMeta|string} metaOrTypeOrUrl
      * @returns {Promise<void>}
      */
     async setAdapter(metaOrTypeOrUrl) {
-      const urlOrUndefined = arguments[1];
-      const tokenOrUndefined = arguments[2];
-      const meta = await this._parseAdapterArgs(metaOrTypeOrUrl, urlOrUndefined, tokenOrUndefined);
-      if (!meta || typeof meta.type !== "string" || meta.opts == null && meta.options == null) throw new Error("Adapter meta is required");
-      const normalized = { type: meta.type, opts: meta.opts || meta.options };
-      this.adapterMeta = normalized;
+      const argument1 = arguments[1];
+      const argument2 = arguments[2];
+      const argument3 = arguments[3];
+      const meta = this._parseAdapterArgs(metaOrTypeOrUrl, argument1, argument2, argument3);
+      if (!meta || typeof meta.type !== "string") throw new Error("Adapter meta is required");
+      this.adapterMeta = meta;
       await this._tryPersistAdapterMeta();
     }
     /**
-     * Parse arguments for `setAdapter` and return normalized meta object.
-     * Accepts AdapterMeta, (type, url, token?), or (url).
+     * Parse arguments for `setAdapter` and return a fully normalized AdapterMeta.
+     * The result always has {type, url, branch, token, opts} at the top level.
+     * Accepts AdapterMeta, (type, url, branch?, token?), or (url, branch?, token?).
      * @param metaOrTypeOrUrl AdapterMeta or type or url
-     * @param urlOrUndefined optional url when first arg is type
-     * @param tokenOrUndefined optional token
-     * @returns normalized meta object
+     * @param argument1 url (when first is type) OR branch (when first is url) OR undefined
+     * @param argument2 branch (when first is type) OR token (when first is url) OR undefined
+     * @param argument3 token (when first is type) OR undefined
+     * @returns normalized AdapterMeta
      */
-    async _parseAdapterArgs(metaOrTypeOrUrl, urlOrUndefined, tokenOrUndefined) {
-      if (typeof metaOrTypeOrUrl === "object" && metaOrTypeOrUrl !== null && !urlOrUndefined) return metaOrTypeOrUrl;
-      if (typeof metaOrTypeOrUrl === "string" && typeof urlOrUndefined === "string") {
-        try {
-          const parsed = parseAdapterFromUrl(urlOrUndefined, tokenOrUndefined, metaOrTypeOrUrl);
-          return { type: parsed.type, opts: parsed.opts };
-        } catch (error) {
-          throw error;
-        }
+    _parseAdapterArgs(metaOrTypeOrUrl, argument1, argument2, argument3) {
+      if (typeof metaOrTypeOrUrl === "object" && metaOrTypeOrUrl !== null) {
+        return this._normalizeFromMeta(metaOrTypeOrUrl);
       }
-      if (typeof metaOrTypeOrUrl === "string" && !urlOrUndefined) {
+      const firstArgument = metaOrTypeOrUrl;
+      const isTypeUrlForm = typeof argument1 === "string" && /^https?:\/\//i.test(argument1);
+      if (isTypeUrlForm) {
+        return this._normalizeFromTypeUrl(firstArgument, argument1, argument2, argument3);
+      }
+      return this._normalizeFromUrl(firstArgument, argument1, argument2);
+    }
+    /**
+     * Normalize from AdapterMeta object – generate url from opts if missing.
+     * @param meta raw AdapterMeta input
+     * @returns fully normalized AdapterMeta
+     */
+    _normalizeFromMeta(meta) {
+      const type = meta.type;
+      const rawOptions = meta.opts || meta.options || {};
+      const options = this._stripOptionsFields(rawOptions);
+      let url = meta.url;
+      if (!url) {
         try {
-          const parsed = parseAdapterFromUrl(metaOrTypeOrUrl);
-          return { type: parsed.type, opts: parsed.opts };
-        } catch (error) {
-          throw error;
+          url = buildUrlFromAdapterOptions(type, options);
+        } catch {
+          url = void 0;
         }
       }
-      throw new Error("Adapter meta is required");
+      const branch = meta.branch || rawOptions.branch || "main";
+      const token = meta.token || rawOptions.token || void 0;
+      return { type, url, branch, token, opts: options };
+    }
+    /**
+     * Normalize from (type, url, branch?, token?) arguments.
+     * @param type adapter type
+     * @param url repository url
+     * @param branch optional branch (defaults to 'main')
+     * @param token optional token
+     * @returns fully normalized AdapterMeta
+     */
+    _normalizeFromTypeUrl(type, url, branch, token) {
+      const parsed = parseAdapterFromUrl(url, token, type);
+      const options = this._stripOptionsFields(parsed.opts || {});
+      return { type: parsed.type, url, branch: branch || "main", token, opts: options };
+    }
+    /**
+     * Normalize from (url, branch?, token?) arguments.
+     * @param url repository url
+     * @param branch optional branch (defaults to 'main')
+     * @param token optional token
+     * @returns fully normalized AdapterMeta
+     */
+    _normalizeFromUrl(url, branch, token) {
+      const parsed = parseAdapterFromUrl(url, token);
+      const options = this._stripOptionsFields(parsed.opts || {});
+      return { type: parsed.type, url, branch: branch || "main", token, opts: options };
+    }
+    /**
+     * Strip branch/token from options to avoid duplication (they live at the top level).
+     * Returns a new object with only host, owner, repo, projectId, etc.
+     * @param options raw adapter options
+     * @returns cleaned options without branch/token
+     */
+    _stripOptionsFields(options) {
+      if (!options || typeof options !== "object") return {};
+      const cleaned = { ...options };
+      delete cleaned.branch;
+      delete cleaned.token;
+      delete cleaned.defaultBranch;
+      delete cleaned.repositoryName;
+      delete cleaned.repositoryId;
+      return cleaned;
+    }
+    /**
+     * Return the persisted branch name from adapterMeta (top-level or opts fallback).
+     * Defaults to 'main' when not found.
+     * @returns {string} persisted branch name
+     */
+    _getPersistedBranch() {
+      if (!this.adapterMeta) return "main";
+      return this.adapterMeta.branch || this.adapterMeta.opts && this.adapterMeta.opts.branch || "main";
     }
     /**
      * Try to inject the configured logger into the adapter instance (best-effort).
@@ -3859,6 +3985,9 @@ var APIGitLib = (() => {
     _instantiateAdapter(type, options) {
       try {
         const optionsWithLogger = { ...options || {} };
+        if (this.adapterMeta && this.adapterMeta.token && !optionsWithLogger.token) {
+          optionsWithLogger.token = this.adapterMeta.token;
+        }
         if (this.logger) optionsWithLogger.logger = this.logger;
         if (type === "github") return new GitHubAdapter(optionsWithLogger);
         if (type === "gitlab") return new GitLabAdapter(optionsWithLogger);
@@ -3945,8 +4074,9 @@ var APIGitLib = (() => {
      * @returns {void}
      */
     _populateCommitShaFromMeta(stats) {
-      if (!stats.gitCommitSha && this.adapterMeta && this.adapterMeta.opts && this.adapterMeta.opts.branch) {
-        stats.gitCommitSha = this.adapterMeta.opts.branch;
+      const branch = this._getPersistedBranch();
+      if (!stats.gitCommitSha && branch && branch !== "main") {
+        stats.gitCommitSha = branch;
       }
     }
     /**
@@ -3959,7 +4089,7 @@ var APIGitLib = (() => {
       if (!instAdapter || stats.gitCommitSha) return;
       if (typeof instAdapter.resolveRef !== "function") return;
       try {
-        const branch = this.adapterMeta && this.adapterMeta.opts && this.adapterMeta.opts.branch || "main";
+        const branch = this._getPersistedBranch();
         const resolved = await instAdapter.resolveRef(branch);
         if (resolved) stats.gitCommitSha = resolved;
       } catch (error) {
@@ -4511,7 +4641,7 @@ var APIGitLib = (() => {
      * @returns {Promise<{commitSha:string}>}
      */
     async _handlePushWithAdapter(input, adapter) {
-      const branch = input.ref || this.adapterMeta && this.adapterMeta.opts && this.adapterMeta.opts.branch || "main";
+      const branch = input.ref || this._getPersistedBranch();
       const messageWithKey = `${input.message}
 
 apigit-commit-key:${input.commitKey}`;
@@ -4585,13 +4715,13 @@ apigit-commit-key:${input.commitKey}`;
       return { ...pullResult, remote: normalized, remotePaths: Object.keys(normalized.shas || {}) };
     }
     /**
-     * Pull using the persisted adapterMeta.opts.branch (or 'main').
+     * Pull using the persisted adapterMeta.branch (or 'main').
      * @param {Record<string,string>=} baseSnapshot optional base snapshot
      * @returns {Promise<any>} pull result
      */
     async _pullUsingPersistedBranch(baseSnapshot) {
       const instAdapter = await this.getAdapterInstance();
-      const branch = this.adapterMeta && this.adapterMeta.opts && this.adapterMeta.opts.branch || "main";
+      const branch = this._getPersistedBranch();
       await this._trySetBackendBranch(branch);
       const resolvedSha = await instAdapter.resolveRef(branch);
       const descriptor = await instAdapter.fetchSnapshot(resolvedSha);
@@ -4624,9 +4754,9 @@ apigit-commit-key:${input.commitKey}`;
      * @returns {Promise<void>}
      */
     async _persistAdapterBranchMeta(branch, _adapterInstance) {
-      const meta = this.adapterMeta && this.adapterMeta.opts ? { ...this.adapterMeta } : await this.getAdapter();
+      const meta = this.adapterMeta ? { ...this.adapterMeta } : await this.getAdapter();
       if (!meta) return;
-      const newMeta = { ...meta || {}, opts: { ...meta.opts || {}, branch } };
+      const newMeta = { ...meta || {}, branch, opts: { ...meta.opts || {} } };
       await this.setAdapter(newMeta);
       await this._trySetBackendBranch(branch);
     }
@@ -4794,7 +4924,7 @@ apigit-commit-key:${input.commitKey}`;
     async _resolveAdapterDefaultBranch(instAdapter) {
       if (this.adapterMeta && this.adapterMeta.opts && typeof instAdapter.resolveRef === "function") {
         try {
-          const defaultBranch = this.adapterMeta.opts.branch || "main";
+          const defaultBranch = this._getPersistedBranch();
           const resolved = await instAdapter.resolveRef(defaultBranch);
           return resolved || null;
         } catch (error) {
@@ -4832,11 +4962,12 @@ apigit-commit-key:${input.commitKey}`;
       try {
         const have = await this._loadAdapterMetaIfNeeded();
         if (!have) return;
-        const options = this.adapterMeta && this.adapterMeta.opts || {};
+        const existing = this.adapterMeta && this.adapterMeta.opts;
+        const options = existing ? { ...existing } : {};
         options.defaultBranch = md.defaultBranch;
         if (md.name) options.repositoryName = md.name;
         if (md.id !== void 0) options.repositoryId = md.id;
-        this.adapterMeta.opts = options;
+        this.adapterMeta.opts = { ...existing, ...options };
         await this._writeAdapterMetaToIndex();
       } catch (error) {
         if (typeof console !== "undefined" && console.debug) console.debug("persist repository metadata aborted", error);
@@ -4921,7 +5052,7 @@ apigit-commit-key:${input.commitKey}`;
     async _fetchSnapshotFromAdapterInstance() {
       const adapterInstance = await this.getAdapterInstance();
       if (adapterInstance && typeof adapterInstance.fetchSnapshot === "function") {
-        const branch = this.adapterMeta && this.adapterMeta.opts && this.adapterMeta.opts.branch || "main";
+        const branch = this._getPersistedBranch();
         return await adapterInstance.fetchSnapshot(branch);
       }
       return null;
@@ -5269,7 +5400,8 @@ apigit-commit-key:${input.commitKey}`;
       if (meta.lastCommitKey) result.lastCommitKey = meta.lastCommitKey;
       if (meta.adapter) result.adapter = meta.adapter;
       try {
-        this.currentBranch = meta.adapter && meta.adapter.opts && meta.adapter.opts.branch ? meta.adapter.opts.branch : null;
+        const adp = meta.adapter;
+        this.currentBranch = adp && (adp.branch || adp.opts && adp.opts.branch) ? adp.branch || adp.opts.branch : null;
       } catch {
         this.currentBranch = null;
       }