browser-git-ops 0.0.7 → 0.0.8

package/dist/index.mjs

@@ -33,9 +33,8 @@ function buildGithubMeta(parsed, hostname, segments, resolvedToken, branchParame
   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`;
   }
@@ -44,14 +43,39 @@ function buildGithubMeta(parsed, hostname, segments, resolvedToken, branchParame
 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";
@@ -1017,6 +1041,10 @@ var NonRetryableError = class extends Error {
 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";
@@ -1250,6 +1278,7 @@ var AbstractGitAdapter = class {
    * @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) {
@@ -1778,6 +1807,9 @@ var GitHubAdapter = class extends abstractAdapter_default {
   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();
@@ -2072,6 +2104,12 @@ var GitLabAdapter = class extends abstractAdapter_default {
       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) : {};
@@ -2224,6 +2262,11 @@ var GitLabAdapter = class extends abstractAdapter_default {
     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 });
@@ -2239,14 +2282,25 @@ var GitLabAdapter = class extends abstractAdapter_default {
   }
   /**
    * 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.
@@ -2278,6 +2332,7 @@ var GitLabAdapter = class extends abstractAdapter_default {
    * @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) {
@@ -2298,6 +2353,7 @@ var GitLabAdapter = class extends abstractAdapter_default {
    * 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) {
@@ -2363,6 +2419,12 @@ var GitLabAdapter = class extends abstractAdapter_default {
     }
     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);
@@ -3700,47 +3762,111 @@ var VirtualFS = class {
    * 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).
@@ -3827,6 +3953,9 @@ var VirtualFS = class {
   _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);
@@ -3913,8 +4042,9 @@ var VirtualFS = class {
    * @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;
     }
   }
   /**
@@ -3927,7 +4057,7 @@ var VirtualFS = class {
     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) {
@@ -4479,7 +4609,7 @@ var VirtualFS = class {
    * @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}`;
@@ -4553,13 +4683,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);
@@ -4592,9 +4722,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);
   }
@@ -4762,7 +4892,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) {
@@ -4800,11 +4930,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);
@@ -4889,7 +5020,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;
@@ -5237,7 +5368,8 @@ var IndexedDatabaseStorage = class IndexedDatabaseStorage2 {
     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;
     }