browser-git-ops 0.0.0 → 0.0.2

package/dist/index.js

@@ -1,14 +1,1168 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.GitLabAdapter = exports.GitHubAdapter = exports.VirtualFS = void 0;
-var virtualfs_1 = require("./virtualfs/virtualfs");
-Object.defineProperty(exports, "VirtualFS", { enumerable: true, get: function () { return __importDefault(virtualfs_1).default; } });
-var githubAdapter_1 = require("./git/githubAdapter");
-Object.defineProperty(exports, "GitHubAdapter", { enumerable: true, get: function () { return __importDefault(githubAdapter_1).default; } });
-var gitlabAdapter_1 = require("./git/gitlabAdapter");
-Object.defineProperty(exports, "GitLabAdapter", { enumerable: true, get: function () { return __importDefault(gitlabAdapter_1).default; } });
-var virtualfs_2 = require("./virtualfs/virtualfs");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(virtualfs_2).default; } });
+var APIGitLib = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    GitHubAdapter: () => githubAdapter_default,
+    GitLabAdapter: () => gitlabAdapter_default,
+    IndexedDbStorage: () => indexedDbStorage_default,
+    OpfsStorage: () => opfsStorage_default,
+    VirtualFS: () => virtualfs_default,
+    default: () => virtualfs_default
+  });
+
+  // src/virtualfs/opfsStorage.ts
+  var ERR_OPFS_DIR_API = "OPFS directory API not available";
+  var OpfsStorage = class {
+    /**
+     * 同期的に OPFS 利用可否を判定します（レガシーヒントも含む）。
+     * @returns {boolean} 利用可能なら true
+     */
+    static canUse() {
+      let ok = false;
+      try {
+        const nav = globalThis.navigator;
+        if (nav && nav.storage && typeof nav.storage.persist === "function")
+          ok = true;
+        if (nav && nav.storage && typeof nav.storage.getDirectory === "function")
+          ok = true;
+      } catch (_) {
+      }
+      if (!ok && globalThis.originPrivateFileSystem && typeof globalThis.originPrivateFileSystem.getDirectory === "function")
+        ok = true;
+      return ok;
+    }
+    /** コンストラクタ（OPFS は初期化不要） */
+    constructor() {
+    }
+    /**
+     * 初期化（OPFS はランタイム判定のみ）
+     * @returns {Promise<void>} 初期化完了時に解決
+     */
+    async init() {
+    }
+    // legacy canUseOpfs removed; use static canUse() instead
+    /**
+     * OPFS のルートディレクトリハンドルを取得します。失敗時は null を返す。
+     * @returns {Promise<any|null>} ルートハンドルまたは null
+     */
+    async getOpfsRoot() {
+      const nav = globalThis.navigator;
+      if (nav && nav.storage && typeof nav.storage.getDirectory === "function") {
+        try {
+          return await nav.storage.getDirectory();
+        } catch (_) {
+        }
+      }
+      try {
+        if (globalThis.originPrivateFileSystem && typeof globalThis.originPrivateFileSystem.getDirectory === "function") {
+          return await globalThis.originPrivateFileSystem.getDirectory();
+        }
+      } catch (_) {
+        return null;
+      }
+      return null;
+    }
+    /**
+     * 指定パスのディレクトリを再帰的に作成して返す
+     * @returns {Promise<any>} 生成されたディレクトリハンドル
+     */
+    async ensureDir(root, parts) {
+      let dir = root;
+      for (const p of parts) {
+        if (dir && typeof dir.getDirectoryHandle === "function") {
+          dir = await dir.getDirectoryHandle(p, { create: true });
+        } else if (dir && typeof dir.getDirectory === "function") {
+          dir = await dir.getDirectory(p, { create: true });
+        } else {
+          throw new Error(ERR_OPFS_DIR_API);
+        }
+      }
+      return dir;
+    }
+    /**
+     * index を読み出す
+     * @returns {Promise<IndexFile|null>} 読み出した IndexFile、存在しなければ null
+     */
+    async readIndex() {
+      try {
+        const root = await this.getOpfsRoot();
+        if (!root)
+          return null;
+        const fh = await root.getFileHandle("index");
+        const file = await fh.getFile();
+        const txt = await file.text();
+        return txt ? JSON.parse(txt) : null;
+      } catch (_) {
+        return null;
+      }
+    }
+    /**
+     * index を書き込む
+     * @returns {Promise<void>} 書込完了時に解決
+     */
+    async writeIndex(index) {
+      const root = await this.getOpfsRoot();
+      if (!root)
+        throw new Error("OPFS not available");
+      const fh = await root.getFileHandle("index", { create: true });
+      const writable = await fh.createWritable();
+      await writable.write(JSON.stringify(index));
+      await writable.close();
+    }
+    /**
+     * blob を書き込む
+     * @returns {Promise<void>} 書込完了時に解決
+     */
+    async writeBlob(filepath, content) {
+      const root = await this.getOpfsRoot();
+      if (!root)
+        throw new Error("OPFS not available");
+      const parts = filepath.split("/");
+      if (parts.length > 1) {
+        const dirParts = parts.slice(0, parts.length - 1);
+        const parent = await this.ensureDir(root, dirParts);
+        const fh2 = await parent.getFileHandle(parts[parts.length - 1], { create: true });
+        const writable2 = await fh2.createWritable();
+        await writable2.write(content);
+        await writable2.close();
+        return;
+      }
+      const fh = await root.getFileHandle(filepath, { create: true });
+      const writable = await fh.createWritable();
+      await writable.write(content);
+      await writable.close();
+    }
+    /**
+     * blob を読み出す
+     * @returns {Promise<string|null>} ファイル内容、存在しなければ null
+     */
+    async readBlob(filepath) {
+      try {
+        const root = await this.getOpfsRoot();
+        if (!root)
+          return null;
+        const parts = filepath.split("/");
+        const dir = await this.traverseDir(root, parts.slice(0, parts.length - 1));
+        const fh = await dir.getFileHandle(parts[parts.length - 1]);
+        const file = await fh.getFile();
+        const txt = await file.text();
+        return txt ?? null;
+      } catch (_) {
+        return null;
+      }
+    }
+    /**
+     * blob を削除する
+     * @returns {Promise<void>} 削除完了時に解決
+     */
+    async deleteBlob(filepath) {
+      try {
+        const root = await this.getOpfsRoot();
+        if (!root)
+          return;
+        const parts = filepath.split("/");
+        const dir = await this.traverseDir(root, parts.slice(0, parts.length - 1));
+        const name = parts[parts.length - 1];
+        if (typeof dir.removeEntry === "function") {
+          await dir.removeEntry(name);
+          return;
+        }
+        if (typeof dir.getFileHandle === "function") {
+          await this.tryRemoveFileHandle(dir, name);
+          return;
+        }
+      } catch (_) {
+      }
+    }
+    /**
+     * Traverse into nested directories without creating them.
+     * @param root The starting directory handle
+     * @param parts Path parts to traverse
+     * @returns The final directory handle
+     */
+    async traverseDir(root, parts) {
+      let dir = root;
+      for (const p of parts) {
+        if (dir && typeof dir.getDirectoryHandle === "function") {
+          dir = await dir.getDirectoryHandle(p);
+        } else if (dir && typeof dir.getDirectory === "function") {
+          dir = await dir.getDirectory(p);
+        } else {
+          throw new Error(ERR_OPFS_DIR_API);
+        }
+      }
+      return dir;
+    }
+    /**
+     * Try to remove a file via its file handle.
+     * @returns {Promise<boolean>} true when removed, false otherwise
+     */
+    async tryRemoveFileHandle(dir, name) {
+      try {
+        const fh = await dir.getFileHandle(name);
+        if (fh && typeof fh.remove === "function") {
+          await fh.remove();
+          return true;
+        }
+      } catch (_) {
+      }
+      return false;
+    }
+  };
+  var opfsStorage_default = OpfsStorage;
+
+  // src/virtualfs/virtualfs.ts
+  var VirtualFS = class {
+    storageDir;
+    base = /* @__PURE__ */ new Map();
+    workspace = /* @__PURE__ */ new Map();
+    tombstones = /* @__PURE__ */ new Map();
+    index = { head: "", entries: {} };
+    backend;
+    /**
+     * VirtualFS のインスタンスを初期化します。
+     * @param options オプション
+     * @returns {void}
+     */
+    constructor(options) {
+      this.storageDir = options?.storageDir;
+      if (options?.backend)
+        this.backend = options.backend;
+      else
+        this.backend = new OpfsStorage();
+    }
+    /**
+     * コンテンツから SHA1 を計算します。
+     * @param {string} content コンテンツ
+     * @returns {string} 計算された SHA
+     */
+    async shaOf(content) {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(content);
+      const hashBuffer = await crypto.subtle.digest("SHA-1", data);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    /**
+     * VirtualFS の初期化を行います（バックエンド初期化と index 読み込み）。
+     * @returns {Promise<void>}
+     */
+    async init() {
+      await this.backend.init();
+      await this.loadIndex();
+    }
+    /**
+     * 永続化レイヤーから index を読み込み、内部マップを初期化します。
+     * @returns {Promise<void>}
+     */
+    async loadIndex() {
+      try {
+        const raw = await this.backend.readIndex();
+        if (raw)
+          this.index = raw;
+        for (const [p, e] of Object.entries(this.index.entries)) {
+          if (e.baseSha) {
+            this.base.set(p, { sha: e.baseSha, content: "" });
+          }
+          if (e.workspaceSha) {
+            this.workspace.set(p, { sha: e.workspaceSha, content: "" });
+          }
+        }
+      } catch (err) {
+        this.index = { head: "", entries: {} };
+        await this.saveIndex();
+      }
+    }
+    /**
+     * 内部インデックスを永続化します。
+     * @returns {Promise<void>}
+     */
+    async saveIndex() {
+      await this.backend.writeIndex(this.index);
+    }
+    /**
+     *
+     */
+    /**
+     * ワークスペースにファイルを書き込みます（ローカル編集）。
+     * @param {string} filepath ファイルパス
+     * @param {string} content コンテンツ
+     * @returns {Promise<void>}
+     */
+    async writeWorkspace(filepath, content) {
+      const sha = await this.shaOf(content);
+      this.workspace.set(filepath, { sha, content });
+      const now = Date.now();
+      const existing = this.index.entries[filepath];
+      const state = existing && existing.baseSha ? "modified" : "added";
+      this.index.entries[filepath] = {
+        path: filepath,
+        state,
+        baseSha: existing?.baseSha,
+        workspaceSha: sha,
+        updatedAt: now
+      };
+      await this.backend.writeBlob(filepath, content);
+      await this.saveIndex();
+    }
+    /**
+     * ワークスペース上のファイルを削除します（トゥームストーン作成を含む）。
+     * @param {string} filepath ファイルパス
+     * @returns {Promise<void>}
+     */
+    async deleteWorkspace(filepath) {
+      const entry = this.index.entries[filepath];
+      const now = Date.now();
+      if (entry && entry.baseSha) {
+        this.tombstones.set(filepath, { path: filepath, baseSha: entry.baseSha, deletedAt: now });
+        this.index.entries[filepath] = {
+          path: filepath,
+          state: "deleted",
+          baseSha: entry.baseSha,
+          updatedAt: now
+        };
+      } else {
+        delete this.index.entries[filepath];
+        this.workspace.delete(filepath);
+        await this.backend.deleteBlob(filepath);
+      }
+      await this.saveIndex();
+    }
+    /**
+     * rename を delete + create の合成で行うヘルパ
+     * @param from 元パス
+     * @param to 新パス
+     */
+    async renameWorkspace(from, to) {
+      const w = this.workspace.get(from);
+      const content = w ? w.content : this.base.get(from)?.content ?? null;
+      if (content === null)
+        throw new Error("source not found");
+      await this.writeWorkspace(to, content);
+      await this.deleteWorkspace(from);
+    }
+    /**
+     * ワークスペース/ベースからファイル内容を読み出します。
+     * @param {string} filepath ファイルパス
+     * @returns {Promise<string|null>} ファイル内容または null
+     */
+    async readWorkspace(filepath) {
+      const w = this.workspace.get(filepath);
+      if (w)
+        return w.content;
+      const blob = await this.backend.readBlob(filepath);
+      if (blob !== null)
+        return blob;
+      const b = this.base.get(filepath);
+      if (b && b.content)
+        return b.content;
+      return null;
+    }
+    /**
+     * リモートのベーススナップショットを適用します。
+     * @param {{[path:string]:string}} snapshot path->content のマップ
+     * @param {string} headSha リモート HEAD
+     * @returns {Promise<void>}
+     */
+    async applyBaseSnapshot(snapshot, headSha) {
+      this.base.clear();
+      for (const [p, c] of Object.entries(snapshot)) {
+        this.base.set(p, { sha: await this.shaOf(c), content: c });
+        await this.backend.writeBlob(p, c);
+      }
+      for (const [p, be] of this.base.entries()) {
+        const existing = this.index.entries[p];
+        if (!existing) {
+          this.index.entries[p] = {
+            path: p,
+            state: "base",
+            baseSha: be.sha,
+            updatedAt: Date.now()
+          };
+        } else if (existing.state === "base") {
+          existing.baseSha = be.sha;
+          existing.updatedAt = Date.now();
+        }
+      }
+      this.index.head = headSha;
+      await this.saveIndex();
+    }
+    /**
+     * インデックス情報を返します。
+     * @returns {IndexFile}
+     */
+    getIndex() {
+      return this.index;
+    }
+    /**
+     * 登録されているパス一覧を返します。
+     * @returns {string[]}
+     */
+    listPaths() {
+      return Object.keys(this.index.entries);
+    }
+    /**
+     * tombstone を返します。
+     * @returns {TombstoneEntry[]}
+     */
+    getTombstones() {
+      return Array.from(this.tombstones.values());
+    }
+    /**
+     * tombstone を返します。
+     * @returns {TombstoneEntry[]}
+     */
+    /**
+      * ワークスペースとインデックスから変更セットを生成します。
+      * @returns {Promise<Array<{type:string,path:string,content?:string,baseSha?:string}>>} 変更リスト
+      */
+    async getChangeSet() {
+      const changes = [];
+      changes.push(...this._changesFromTombstones());
+      changes.push(...this._changesFromIndexEntries());
+      return changes;
+    }
+    /**
+     * tombstone からの削除変更リストを生成します。
+     * @returns {Array<{type:'delete',path:string,baseSha:string}>}
+     */
+    _changesFromTombstones() {
+      const out = [];
+      for (const t of this.tombstones.values())
+        out.push({ type: "delete", path: t.path, baseSha: t.baseSha });
+      return out;
+    }
+    /**
+     * index entries から create/update の変更リストを生成します。
+     * @returns {Array<{type:'create'|'update',path:string,content:string,baseSha?:string}>}
+     */
+    _changesFromIndexEntries() {
+      const out = [];
+      out.push(...this._changesFromAddedEntries());
+      out.push(...this._changesFromModifiedEntries());
+      return out;
+    }
+    /**
+     * 追加状態のエントリから create 変更を生成します。
+     * @returns {Array<{type:'create',path:string,content:string}>}
+     */
+    _changesFromAddedEntries() {
+      const out = [];
+      for (const [p, e] of Object.entries(this.index.entries)) {
+        if (e.state === "added") {
+          const w = this.workspace.get(p);
+          if (w)
+            out.push({ type: "create", path: p, content: w.content });
+        }
+      }
+      return out;
+    }
+    /**
+     * 変更状態のエントリから update 変更を生成します。
+     * @returns {Array<{type:'update',path:string,content:string,baseSha:string}>}
+     */
+    _changesFromModifiedEntries() {
+      const out = [];
+      for (const [p, e] of Object.entries(this.index.entries)) {
+        if (e.state === "modified") {
+          const w = this.workspace.get(p);
+          if (w && e.baseSha)
+            out.push({ type: "update", path: p, content: w.content, baseSha: e.baseSha });
+        }
+      }
+      return out;
+    }
+    /**
+     * リモートスナップショットからの差分取り込み時に、単一パスを評価して
+     * 必要なら conflicts に追加、もしくは base を更新します。
+     * @returns {Promise<void>}
+     */
+    async _handleRemotePath(p, remoteSha, baseSnapshot, conflicts) {
+      const idxEntry = this.index.entries[p];
+      const localWorkspace = this.workspace.get(p);
+      const localBase = this.base.get(p);
+      if (!idxEntry)
+        return await this._handleRemoteNew(p, remoteSha, baseSnapshot, conflicts, localWorkspace, localBase);
+      return await this._handleRemoteExisting(p, idxEntry, remoteSha, baseSnapshot, conflicts, localWorkspace);
+    }
+    /**
+     * リモートに存在するがローカルにないパスを処理します。
+     * @returns {Promise<void>}
+     */
+    async _handleRemoteNew(p, remoteSha, baseSnapshot, conflicts, localWorkspace, localBase) {
+      if (localWorkspace) {
+        conflicts.push({ path: p, remoteSha, workspaceSha: localWorkspace.sha, baseSha: localBase?.sha });
+      } else {
+        const content = baseSnapshot[p];
+        this.base.set(p, { sha: remoteSha, content });
+        this.index.entries[p] = { path: p, state: "base", baseSha: remoteSha, updatedAt: Date.now() };
+        await this.backend.writeBlob(p, content);
+      }
+    }
+    /**
+     * リモートに存在し、かつローカルにエントリがあるパスを処理します。
+     * @returns {Promise<void>}
+     */
+    async _handleRemoteExisting(p, idxEntry, remoteSha, baseSnapshot, conflicts, localWorkspace) {
+      const baseSha = idxEntry.baseSha;
+      if (baseSha === remoteSha)
+        return;
+      if (!localWorkspace || localWorkspace.sha === baseSha) {
+        const content = baseSnapshot[p];
+        this.base.set(p, { sha: remoteSha, content });
+        idxEntry.baseSha = remoteSha;
+        idxEntry.state = "base";
+        idxEntry.updatedAt = Date.now();
+        await this.backend.writeBlob(p, content);
+      } else {
+        conflicts.push({ path: p, baseSha, remoteSha, workspaceSha: localWorkspace?.sha });
+      }
+    }
+    /**
+     * ローカルに対する変更（create/update/delete）を適用するヘルパー
+     * @param {any} ch 変更オブジェクト
+     * @returns {Promise<void>}
+     */
+    async _applyChangeLocally(ch) {
+      if (ch.type === "create" || ch.type === "update") {
+        const sha = await this.shaOf(ch.content);
+        this.base.set(ch.path, { sha, content: ch.content });
+        const entry = this.index.entries[ch.path] || { path: ch.path };
+        entry.baseSha = sha;
+        entry.state = "base";
+        entry.updatedAt = Date.now();
+        entry.workspaceSha = void 0;
+        this.index.entries[ch.path] = entry;
+        await this.backend.writeBlob(ch.path, ch.content);
+        this.workspace.delete(ch.path);
+      } else if (ch.type === "delete") {
+        delete this.index.entries[ch.path];
+        this.base.delete(ch.path);
+        this.tombstones.delete(ch.path);
+        await this.backend.deleteBlob(ch.path);
+        this.workspace.delete(ch.path);
+      }
+    }
+    /**
+     * リモート側で削除されたエントリをローカルに反映します。
+     * @returns {Promise<void>}
+     */
+    async _handleRemoteDeletion(p, e, _remoteShas, conflicts) {
+      const localWorkspace = this.workspace.get(p);
+      if (!localWorkspace || localWorkspace.sha === e.baseSha) {
+        delete this.index.entries[p];
+        this.base.delete(p);
+        await this.backend.deleteBlob(p);
+      } else {
+        conflicts.push({ path: p, baseSha: e.baseSha, workspaceSha: localWorkspace?.sha });
+      }
+    }
+    /**
+     * GitLab 風の actions ベースコミットフローで push を実行します。
+     * @returns {Promise<{commitSha:string}>}
+     */
+    async _pushWithActions(adapter, input, branch) {
+      const commitSha = await adapter.createCommitWithActions(branch, input.message, input.changes);
+      try {
+        await adapter.updateRef(`heads/${branch}`, commitSha);
+      } catch (e) {
+      }
+      for (const ch of input.changes) {
+        await this._applyChangeLocally(ch);
+      }
+      this.index.head = commitSha;
+      await this.saveIndex();
+      return { commitSha };
+    }
+    /**
+     * GitHub 風の blob/tree/commit フローで push を実行します。
+     * @returns {Promise<{commitSha:string}>}
+     */
+    async _pushWithGitHubFlow(adapter, input, branch) {
+      const blobMap = await adapter.createBlobs(input.changes);
+      const changesWithBlob = input.changes.map((c) => ({ ...c, blobSha: blobMap[c.path] }));
+      const treeSha = await adapter.createTree(changesWithBlob);
+      const commitSha = await adapter.createCommit(input.message, input.parentSha, treeSha);
+      try {
+        await adapter.updateRef(`heads/${branch}`, commitSha);
+      } catch (e) {
+      }
+      for (const ch of input.changes) {
+        await this._applyChangeLocally(ch);
+      }
+      this.index.head = commitSha;
+      await this.saveIndex();
+      return { commitSha };
+    }
+    /**
+     * リモートのスナップショットを取り込み、コンフリクト情報を返します。
+     * @param {string} remoteHead リモート HEAD
+     * @param {{[path:string]:string}} baseSnapshot path->content マップ
+     * @returns {Promise<{conflicts:Array<import('./types').ConflictEntry>}>}
+     */
+    async pull(remoteHead, baseSnapshot) {
+      const conflicts = [];
+      const remoteShas = {};
+      for (const [p, c] of Object.entries(baseSnapshot)) {
+        remoteShas[p] = await this.shaOf(c);
+      }
+      for (const [p, remoteSha] of Object.entries(remoteShas)) {
+        await this._handleRemotePath(p, remoteSha, baseSnapshot, conflicts);
+      }
+      for (const [p, e] of Object.entries(this.index.entries)) {
+        if (!(p in remoteShas)) {
+          await this._handleRemoteDeletion(p, e, remoteShas, conflicts);
+        }
+      }
+      if (conflicts.length === 0) {
+        this.index.head = remoteHead;
+        await this.saveIndex();
+      }
+      return { conflicts };
+    }
+    /**
+     * 変更をコミットしてリモートへ反映します。adapter が無ければローカルシミュレーションします。
+     * @param {import('./types').CommitInput} input コミット入力
+     * @param {import('../git/adapter').GitAdapter} [adapter] 任意のアダプタ
+     * @returns {Promise<{commitSha:string}>}
+     */
+    async push(input, adapter) {
+      if (input.parentSha !== this.index.head) {
+        throw new Error("HEAD changed. pull required");
+      }
+      if (!input.commitKey) {
+        input.commitKey = await this.shaOf(input.parentSha + JSON.stringify(input.changes));
+      }
+      if (!input.changes || input.changes.length === 0)
+        throw new Error("No changes to commit");
+      if (adapter) {
+        const branch = input.ref || "main";
+        const messageWithKey = `${input.message}
+
+apigit-commit-key:${input.commitKey}`;
+        if (adapter.createCommitWithActions) {
+          input.message = messageWithKey;
+          const res2 = await this._pushWithActions(adapter, input, branch);
+          this.index.lastCommitKey = input.commitKey;
+          return res2;
+        }
+        input.message = messageWithKey;
+        const res = await this._pushWithGitHubFlow(adapter, input, branch);
+        this.index.lastCommitKey = input.commitKey;
+        return res;
+      }
+      const commitSha = await this.shaOf(input.parentSha + "|" + input.commitKey);
+      for (const ch of input.changes) {
+        await this._applyChangeLocally(ch);
+      }
+      this.index.head = commitSha;
+      this.index.lastCommitKey = input.commitKey;
+      await this.saveIndex();
+      return { commitSha };
+    }
+  };
+  var virtualfs_default = VirtualFS;
+
+  // src/virtualfs/indexedDbStorage.ts
+  var IndexedDbStorage = class {
+    /**
+     * 環境に IndexedDB が存在するかを同期検査します。
+      * @returns {boolean} 利用可能なら true
+     */
+    static canUse() {
+      try {
+        return !!globalThis.indexedDB;
+      } catch (_) {
+        return false;
+      }
+    }
+    dbName = "apigit_storage";
+    dbPromise;
+    /** コンストラクタ */
+    constructor() {
+      this.dbPromise = this.openDb();
+    }
+    /**
+     * 初期化: DB をオープンするまで待つ
+     * @returns {Promise<void>} 初期化完了時に解決
+     */
+    async init() {
+      await this.dbPromise;
+    }
+    /**
+     * DB を開いて objectStore を初期化する
+     * @returns {Promise<IDBDatabase>} Opened IDBDatabase
+     */
+    openDb() {
+      return new Promise((resolve, reject) => {
+        const idb = globalThis.indexedDB;
+        if (!idb)
+          return reject(new Error("IndexedDB is not available"));
+        const req = idb.open(this.dbName, 1);
+        function handleUpgrade(ev) {
+          const db = ev.target.result;
+          if (!db.objectStoreNames.contains("blobs"))
+            db.createObjectStore("blobs");
+          if (!db.objectStoreNames.contains("index"))
+            db.createObjectStore("index");
+        }
+        req.onupgradeneeded = handleUpgrade;
+        function makeVersionChangeHandler(dbParam) {
+          return function() {
+            try {
+              dbParam.close();
+            } catch (_) {
+            }
+          };
+        }
+        function handleSuccess() {
+          const db = req.result;
+          try {
+            db.onversionchange = makeVersionChangeHandler(db);
+          } catch (_) {
+          }
+          resolve(db);
+        }
+        function handleError() {
+          reject(req.error);
+        }
+        req.onsuccess = handleSuccess;
+        req.onerror = handleError;
+      });
+    }
+    /**
+     * トランザクションラッパー。cb 内の処理をトランザクションで実行し、
+     * 必要なら再試行します。
+     */
+    /**
+     * トランザクションラッパー。cb 内の処理をトランザクションで実行し、必要なら再試行します。
+     * @returns {Promise<void>} トランザクション処理完了時に解決
+     */
+    async tx(storeName, mode, cb) {
+      const attempt = async () => {
+        const db = await this.dbPromise;
+        return new Promise((resolve, reject) => {
+          let tx;
+          try {
+            tx = db.transaction(storeName, mode);
+          } catch (err) {
+            return reject(err);
+          }
+          const storeObj = tx.objectStore(storeName);
+          function handleTxComplete() {
+            resolve();
+          }
+          function handleTxError() {
+            reject(tx.error);
+          }
+          Promise.resolve(cb(storeObj)).then(() => {
+            tx.oncomplete = handleTxComplete;
+            tx.onerror = handleTxError;
+          }).catch(reject);
+        });
+      };
+      try {
+        return await attempt();
+      } catch (err) {
+        const isInvalidState = err && (err.name === "InvalidStateError" || /closing/i.test(String(err.message || "")));
+        if (isInvalidState) {
+          this.dbPromise = this.openDb();
+          return await attempt();
+        }
+        throw err;
+      }
+    }
+    // legacy canUseOpfs removed; use static canUse() instead
+    /**
+     * index を読み出す
+     * @returns {Promise<IndexFile|null>} 読み出した IndexFile、存在しなければ null
+     */
+    async readIndex() {
+      const db = await this.dbPromise;
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction("index", "readonly");
+        const store = tx.objectStore("index");
+        const req = store.get("index");
+        function handleIndexSuccess() {
+          resolve(req.result ?? null);
+        }
+        function handleIndexError() {
+          reject(req.error);
+        }
+        req.onsuccess = handleIndexSuccess;
+        req.onerror = handleIndexError;
+      });
+    }
+    /**
+     * index を書き込む
+     * @returns {Promise<void>} 書込完了時に解決
+     */
+    async writeIndex(index) {
+      await this.tx("index", "readwrite", (store) => {
+        store.put(index, "index");
+      });
+    }
+    /**
+     * blob を書き込む
+     * @returns {Promise<void>} 書込完了時に解決
+     */
+    async writeBlob(filepath, content) {
+      await this.tx("blobs", "readwrite", (store) => {
+        store.put(content, filepath);
+      });
+    }
+    /**
+     * blob を読み出す
+     * @returns {Promise<string|null>} ファイル内容、存在しなければ null
+     */
+    async readBlob(filepath) {
+      const db = await this.dbPromise;
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction("blobs", "readonly");
+        const store = tx.objectStore("blobs");
+        const req = store.get(filepath);
+        function handleBlobSuccess() {
+          resolve(req.result ?? null);
+        }
+        function handleBlobError() {
+          reject(req.error);
+        }
+        req.onsuccess = handleBlobSuccess;
+        req.onerror = handleBlobError;
+      });
+    }
+    /**
+     * blob を削除する
+     * @returns {Promise<void>} 削除完了時に解決
+     */
+    async deleteBlob(filepath) {
+      await this.tx("blobs", "readwrite", (store) => {
+        store.delete(filepath);
+      });
+    }
+  };
+  var indexedDbStorage_default = IndexedDbStorage;
+
+  // src/git/githubAdapter.ts
+  var RetryableError = class extends Error {
+  };
+  var NonRetryableError = class extends Error {
+  };
+  function sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+  }
+  async function fetchWithRetry(input, init, attempts = 4, baseDelay = 300) {
+    let lastErr;
+    for (let i = 0; i < attempts; i++) {
+      try {
+        const res = await fetch(input, init);
+        return await processResponseWithDelay(res, i, baseDelay);
+      } catch (err) {
+        if (err instanceof NonRetryableError)
+          throw err;
+        lastErr = err;
+        await sleep(getDelayForResponse(null, i, baseDelay));
+      }
+    }
+    throw new RetryableError(`Failed after ${attempts} attempts: ${lastErr}`);
+  }
+  function classifyStatus(status) {
+    return status >= 500 || status === 429;
+  }
+  function getDelayForResponse(res, i, baseDelay) {
+    if (!res)
+      return baseDelay * Math.pow(2, i) + Math.random() * 100;
+    const retryAfter = res.headers.get("Retry-After");
+    return retryAfter ? Number(retryAfter) * 1e3 : baseDelay * Math.pow(2, i) + Math.random() * 100;
+  }
+  async function processResponseWithDelay(res, i, baseDelay) {
+    if (res.ok)
+      return res;
+    if (classifyStatus(res.status)) {
+      await sleep(getDelayForResponse(res, i, baseDelay));
+      throw new RetryableError(`HTTP ${res.status}`);
+    }
+    const txt = await res.text().catch(() => "");
+    throw new NonRetryableError(`HTTP ${res.status}: ${txt}`);
+  }
+  function mapWithConcurrency(items, mapper, concurrency = 5) {
+    const results = [];
+    let idx = 0;
+    const runners = [];
+    const run = async () => {
+      while (idx < items.length) {
+        const i = idx++;
+        if (i >= items.length)
+          break;
+        const r = await mapper(items[i]);
+        results[i] = r;
+      }
+    };
+    for (let i = 0; i < Math.min(concurrency, items.length); i++)
+      runners.push(run());
+    return Promise.all(runners).then(() => results);
+  }
+  var GitHubAdapter = class {
+    constructor(opts) {
+      this.opts = opts;
+      this.baseUrl = `https://api.github.com/repos/${opts.owner}/${opts.repo}`;
+      this.headers = {
+        Authorization: `token ${opts.token}`,
+        Accept: "application/vnd.github+json",
+        "Content-Type": "application/json"
+      };
+      this._fetchWithRetry = fetchWithRetry;
+    }
+    baseUrl;
+    headers;
+    _fetchWithRetry;
+    // simple in-memory blob cache: contentSha -> blobSha
+    blobCache = /* @__PURE__ */ new Map();
+    async createBlobs(changes, concurrency = 5) {
+      const tasks = changes.filter((c) => c.type === "create" || c.type === "update");
+      const mapper = async (ch) => {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(ch.content || "");
+        const buf = await crypto.subtle.digest("SHA-1", data);
+        const contentHash = Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+        const cached = this.blobCache.get(contentHash);
+        if (cached)
+          return { path: ch.path, sha: cached };
+        const body = JSON.stringify({ content: ch.content, encoding: "utf-8" });
+        const res = await this._fetchWithRetry(`${this.baseUrl}/git/blobs`, { method: "POST", headers: this.headers, body }, 4, 300);
+        const j = await res.json();
+        if (!j.sha)
+          throw new NonRetryableError("blob response missing sha");
+        this.blobCache.set(contentHash, j.sha);
+        return { path: ch.path, sha: j.sha };
+      };
+      const results = await mapWithConcurrency(tasks, mapper, concurrency);
+      const map = {};
+      for (const r of results)
+        map[r.path] = r.sha;
+      return map;
+    }
+    async createTree(changes, baseTreeSha) {
+      const tree = [];
+      for (const c of changes) {
+        if (c.type === "delete") {
+          tree.push({ path: c.path, mode: "100644", sha: null });
+        } else {
+          if (!c.blobSha)
+            throw new NonRetryableError(`missing blobSha for ${c.path}`);
+          tree.push({ path: c.path, mode: "100644", type: "blob", sha: c.blobSha });
+        }
+      }
+      const body = { tree };
+      if (baseTreeSha)
+        body.base_tree = baseTreeSha;
+      const res = await this._fetchWithRetry(`${this.baseUrl}/git/trees`, { method: "POST", headers: this.headers, body: JSON.stringify(body) }, 4, 300);
+      const j = await res.json();
+      if (!j.sha)
+        throw new NonRetryableError("createTree response missing sha");
+      return j.sha;
+    }
+    async createCommit(message, parentSha, treeSha) {
+      const body = JSON.stringify({ message, tree: treeSha, parents: [parentSha] });
+      const res = await this._fetchWithRetry(`${this.baseUrl}/git/commits`, { method: "POST", headers: this.headers, body }, 4, 300);
+      const j = await res.json();
+      if (!j.sha)
+        throw new NonRetryableError("createCommit response missing sha");
+      return j.sha;
+    }
+    async updateRef(ref, commitSha, force = false) {
+      const body = JSON.stringify({ sha: commitSha, force });
+      const res = await this._fetchWithRetry(`${this.baseUrl}/git/refs/${ref}`, { method: "PATCH", headers: this.headers, body }, 4, 300);
+      if (!res.ok) {
+        const txt = await res.text().catch(() => "");
+        throw new NonRetryableError(`updateRef failed: ${res.status} ${txt}`);
+      }
+    }
+  };
+  var githubAdapter_default = GitHubAdapter;
+
+  // src/git/gitlabAdapter.ts
+  var GitLabAdapter = class {
+    /**
+     * GitLabAdapter を初期化します。
+     * @param {GLOpts} opts 設定オブジェクト
+     */
+    constructor(opts) {
+      this.opts = opts;
+      const host = opts.host || "https://gitlab.com";
+      this.baseUrl = `${host}/api/v4/projects/${encodeURIComponent(opts.projectId)}`;
+      this.headers = { "PRIVATE-TOKEN": opts.token, "Content-Type": "application/json" };
+    }
+    baseUrl;
+    headers;
+    pendingActions = null;
+    maxRetries = 3;
+    baseBackoff = 300;
+    /**
+     * コンテンツから sha1 を算出します。
+     * @param {string} content コンテンツ
+     * @returns {string} sha1 ハッシュ
+     */
+    async shaOf(content) {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(content);
+      const buf = await crypto.subtle.digest("SHA-1", data);
+      return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    /**
+     * 変更一覧から blob sha のマップを作成します（疑似実装）。
+     * @param {any[]} changes 変更一覧
+     * @returns {Promise<Record<string,string>>} path->sha マップ
+     */
+    async createBlobs(changes) {
+      const map = {};
+      for (const c of changes) {
+        if (c.type === "create" || c.type === "update")
+          map[c.path] = await this.shaOf(c.content);
+      }
+      return map;
+    }
+    /**
+     * 互換用のツリー作成。実際には actions を保持しておき、マーカーを返します。
+     * @param {any[]} _changes 変更一覧
+     * @param {string} [_baseTreeSha] ベースツリー（未使用）
+     * @returns {Promise<string>} マーカー文字列
+     */
+    async createTree(_changes, _baseTreeSha) {
+      const actions = (_changes || []).map((c) => {
+        if (c.type === "delete")
+          return { action: "delete", file_path: c.path };
+        if (c.type === "create")
+          return { action: "create", file_path: c.path, content: c.content };
+        return { action: "update", file_path: c.path, content: c.content };
+      });
+      this.pendingActions = actions;
+      return `gitlab-tree-${Date.now()}-${Math.floor(Math.random() * 1e5)}`;
+    }
+    /**
+     * createTree で保持した actions があればコミットし、なければ parentSha を返します。
+     * @param {string} message コミットメッセージ
+     * @param {string} parentSha 親コミット SHA
+     * @param {string} _treeSha ツリー SHA（未使用）
+     * @returns {Promise<string>} 新規コミット SHA または parentSha
+     */
+    async createCommit(message, parentSha, _treeSha) {
+      if (this.pendingActions && this.pendingActions.length > 0) {
+        const branch = "main";
+        const res = await this.createCommitWithActions(
+          branch,
+          message,
+          this.pendingActions.map((a) => ({ type: a.action === "delete" ? "delete" : a.action === "create" ? "create" : "update", path: a.file_path, content: a.content }))
+        );
+        this.pendingActions = null;
+        return res;
+      }
+      return parentSha;
+    }
+    /**
+     * actions を用いて GitLab のコミット API を呼び出します。
+     * @param {string} branch ブランチ名
+     * @param {string} message コミットメッセージ
+     * @param {{type:string,path:string,content?:string}[]} changes 変更一覧
+     * @returns {Promise<any>} コミット応答（id など）
+     */
+    async createCommitWithActions(branch, message, changes) {
+      const url = `${this.baseUrl}/repository/commits`;
+      const actions = changes.map((c) => {
+        if (c.type === "delete")
+          return { action: "delete", file_path: c.path };
+        if (c.type === "create")
+          return { action: "create", file_path: c.path, content: c.content };
+        return { action: "update", file_path: c.path, content: c.content };
+      });
+      const body = JSON.stringify({ branch, commit_message: message, actions });
+      const res = await this.fetchWithRetry(url, { method: "POST", headers: this.headers, body });
+      const text = await res.text().catch(() => "");
+      let j = null;
+      try {
+        j = text ? JSON.parse(text) : null;
+      } catch (err) {
+        throw new Error(`GitLab commit invalid JSON response: ${text}`);
+      }
+      if (!j || !j.id && !j.commit) {
+        throw new Error(`GitLab commit unexpected response: ${JSON.stringify(j)}`);
+      }
+      return j.id || j.commit || j;
+    }
+    /**
+     * fetch をリトライ付きで実行します。
+     * @param {string} url リクエスト URL
+     * @param {RequestInit} opts fetch オプション
+     * @param {number} [retries] 最大リトライ回数
+     * @returns {Promise<Response>} レスポンス
+     */
+    async fetchWithRetry(url, opts, retries = this.maxRetries) {
+      for (let attempt = 1; attempt <= retries; attempt++) {
+        try {
+          const res = await fetch(url, opts);
+          if (!this.isRetryableStatus(res.status))
+            return res;
+          if (attempt === retries)
+            return res;
+          const wait = this.backoffMs(attempt);
+          await new Promise((r) => setTimeout(r, wait));
+        } catch (err) {
+          if (attempt === retries)
+            throw err;
+          const wait = this.backoffMs(attempt);
+          await new Promise((r) => setTimeout(r, wait));
+        }
+      }
+      throw new Error("fetchWithRetry: unexpected exit");
+    }
+    /**
+     * ステータスが再試行対象か判定します。
+     * @param {number} status ステータスコード
+     * @returns {boolean}
+     */
+    isRetryableStatus(status) {
+      return status === 429 || status >= 500 && status < 600;
+    }
+    /**
+     * バックオフ時間を計算します。
+     * @param {number} attempt 試行回数（1..）
+     * @returns {number} ミリ秒
+     */
+    backoffMs(attempt) {
+      const base = this.baseBackoff * Math.pow(2, attempt - 1);
+      const jitter = Math.floor(Math.random() * base * 0.3);
+      return base + jitter;
+    }
+    /**
+     * リファレンス更新は不要なため noop 実装です。
+     * @param {string} _ref ref 名
+     * @param {string} _commitSha コミット SHA
+     * @param {boolean} [_force]
+     * @returns {Promise<void>}
+     */
+    async updateRef(_ref, _commitSha, _force = false) {
+    }
+  };
+  var gitlabAdapter_default = GitLabAdapter;
+  return __toCommonJS(src_exports);
+})();
+//# sourceMappingURL=index.js.map