gutterpress 0.11.6-alpha.3 → 0.11.6

package/dist/index-8xkw284t.js

@@ -1,696 +0,0 @@
-import {
-  capabilitiesFor,
-  detectProjectSource,
-  findEnclosingRepoDir
-} from "./index-v5mp7a6q.js";
-
-// src/lib/git-fs.ts
-import * as nodeFs from "node:fs";
-var MUTABLE_GIT_METADATA = /(?:^|[\\/])\.git[\\/](?:index|HEAD|packed-refs|refs[\\/].+)$/;
-function needsAtomicWrite(file) {
-  return typeof file === "string" && MUTABLE_GIT_METADATA.test(file);
-}
-var tempCounter = 0;
-function tempPathFor(file) {
-  return `${file}.gp${process.pid.toString(36)}-${(tempCounter++).toString(36)}.tmp`;
-}
-function writeFile2(file, data, options, callback) {
-  const cb = typeof options === "function" ? options : callback;
-  const opts = typeof options === "function" ? undefined : options;
-  if (!needsAtomicWrite(file)) {
-    nodeFs.writeFile(file, data, opts, cb);
-    return;
-  }
-  const temp = tempPathFor(file);
-  const failed = (err) => nodeFs.unlink(temp, () => cb(err));
-  nodeFs.writeFile(temp, data, opts, (writeErr) => {
-    if (writeErr)
-      return failed(writeErr);
-    nodeFs.rename(temp, file, (renameErr) => {
-      if (renameErr)
-        return failed(renameErr);
-      cb(null);
-    });
-  });
-}
-async function writeFilePromise(file, data, options) {
-  if (!needsAtomicWrite(file)) {
-    return nodeFs.promises.writeFile(file, data, options);
-  }
-  const temp = tempPathFor(file);
-  try {
-    await nodeFs.promises.writeFile(temp, data, options);
-    await nodeFs.promises.rename(temp, file);
-  } catch (err) {
-    await nodeFs.promises.unlink(temp).catch(() => {});
-    throw err;
-  }
-}
-var promises2 = {
-  ...nodeFs.promises,
-  writeFile: writeFilePromise
-};
-var gitFs = {
-  ...nodeFs,
-  writeFile: writeFile2,
-  promises: promises2
-};
-
-// src/lib/source-provider.ts
-import path2 from "node:path";
-import git from "isomorphic-git";
-
-// src/lib/remote-auth/operation-log.ts
-import { appendFileSync, mkdirSync } from "node:fs";
-import path from "node:path";
-function sanitizeLogText(value, secrets = []) {
-  let text = value;
-  for (const secret of secrets) {
-    if (!secret)
-      continue;
-    for (const form of [secret, encodeURIComponent(secret)]) {
-      text = text.split(form).join("[redacted]");
-    }
-  }
-  return text.replace(/\/\/[^/\s]*@/g, "//").replace(/([?&](?:access_token|token|password|secret|key|code)=)[^&#\s]*/gi, "$1[redacted]").replace(/\b(Bearer|Basic)\s+[A-Za-z0-9+/_.=~-]+/gi, "$1 [redacted]").replace(/\b(?:gh[pousr]_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+)/g, "[redacted]").replace(/[\s\x00-\x1f\x7f]+/g, " ").trim().slice(0, 6000);
-}
-function errorLogData(error) {
-  const out = { error: error == null ? String(error) : undefined };
-  let current = error;
-  const seen = new Set;
-  for (let depth = 0;depth < 3 && current != null && !seen.has(current); depth++) {
-    seen.add(current);
-    const prefix = depth === 0 ? "" : `cause${depth}_`;
-    if (typeof current !== "object") {
-      out[`${prefix}error`] = String(current);
-      break;
-    }
-    const err = current;
-    out[`${prefix}error`] = typeof err.message === "string" ? err.message : "Unknown error";
-    for (const key of ["code", "name", "caller", "stack", "syscall", "path"]) {
-      if (typeof err[key] === "string")
-        out[`${prefix}${key}`] = err[key];
-    }
-    const data = err.data;
-    if (data && typeof data === "object") {
-      for (const key of [
-        "statusCode",
-        "reason",
-        "prettyDetails",
-        "oid",
-        "ref",
-        "what",
-        "filepath",
-        "filepaths",
-        "bothModified",
-        "deleteByUs",
-        "deleteByTheirs"
-      ]) {
-        const value = data[key];
-        if (typeof value === "string" || typeof value === "number")
-          out[`${prefix}${key}`] = value;
-        else if (Array.isArray(value)) {
-          out[`${prefix}${key}`] = value.filter((v) => typeof v === "string").slice(0, 50);
-          if (value.length > 50)
-            out[`${prefix}${key}Count`] = value.length;
-        }
-      }
-    }
-    current = err.cause;
-  }
-  return out;
-}
-var noop = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {}
-};
-var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
-function createFileLogger(logFile, operation, minLevel = "debug", options = {}) {
-  try {
-    mkdirSync(path.dirname(logFile), { recursive: true });
-  } catch {
-    return noop;
-  }
-  function write(level, step, message, data) {
-    if (LEVEL_ORDER[level] < LEVEL_ORDER[minLevel])
-      return;
-    const ts = new Date().toISOString();
-    const clean = (value) => sanitizeLogText(value, options.secrets);
-    const fields = formatData({ ...options.context, ...data }, clean);
-    const line = `[${ts}] ${level.toUpperCase().padEnd(5)} ${clean(operation)}: step=${clean(step)}${fields} | ${clean(message)}
-`;
-    try {
-      appendFileSync(logFile, line, "utf8");
-    } catch {}
-  }
-  return {
-    debug: (step, message, data) => write("debug", step, message, data),
-    info: (step, message, data) => write("info", step, message, data),
-    warn: (step, message, data) => write("warn", step, message, data),
-    error: (step, message, data) => write("error", step, message, data)
-  };
-}
-function resolveLogger(logFile, operation, options = {}) {
-  if (!logFile)
-    return noop;
-  return createFileLogger(logFile, operation, "debug", options);
-}
-function formatData(data, clean) {
-  if (!data)
-    return "";
-  const parts = [];
-  for (const [key, value] of Object.entries(data)) {
-    if (value === undefined)
-      continue;
-    if (Array.isArray(value)) {
-      parts.push(`${clean(key)}=${clean(value.join(","))}`);
-    } else {
-      parts.push(`${clean(key)}=${clean(String(value))}`);
-    }
-  }
-  return parts.length > 0 ? " " + parts.join(" ") : "";
-}
-
-// src/lib/source-provider.ts
-var noopLogger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {}
-};
-function gitScopeFor(source) {
-  return source.repoRoot || source.path;
-}
-var HISTORY_PAGE_LIMIT = 100;
-var DEFAULT_AUTHOR = "gutterpress";
-var DEFAULT_EMAIL = "noreply@gutterpress.local";
-var DEFAULT_BRANCH = "main";
-var SNAPSHOT_STAGING_MARKER = "gutterpress-snapshot-staging";
-var repoQueues = new Map;
-function repoLockKey(projectDir) {
-  const resolved = path2.resolve(projectDir);
-  try {
-    return gitFs.realpathSync(resolved);
-  } catch {
-    return resolved;
-  }
-}
-function withRepoLock(projectDir, fn) {
-  const key = repoLockKey(projectDir);
-  const prev = repoQueues.get(key) ?? Promise.resolve();
-  const run = prev.then(fn, fn);
-  const tail = run.then(() => {
-    return;
-  }, () => {
-    return;
-  });
-  repoQueues.set(key, tail);
-  tail.then(() => {
-    if (repoQueues.get(key) === tail)
-      repoQueues.delete(key);
-  });
-  return run;
-}
-function __repoLockQueueSizeForTests() {
-  return repoQueues.size;
-}
-function gitAuthor(name, email) {
-  const n = (name ?? "").trim();
-  const e = (email ?? "").trim();
-  return { name: n || DEFAULT_AUTHOR, email: e || DEFAULT_EMAIL };
-}
-async function readGitAuthor(dir) {
-  const [name, email] = await Promise.all([
-    git.getConfig({ fs: gitFs, dir, path: "user.name" }).catch(() => {
-      return;
-    }),
-    git.getConfig({ fs: gitFs, dir, path: "user.email" }).catch(() => {
-      return;
-    })
-  ]);
-  return {
-    name: typeof name === "string" ? name : undefined,
-    email: typeof email === "string" ? email : undefined
-  };
-}
-async function resolveGitAuthor(dir, name, email) {
-  const existing = await readGitAuthor(dir);
-  return gitAuthor(name || existing.name, email || existing.email);
-}
-async function listWorkdirChanges(dir, cache = {}) {
-  const adds = [];
-  const removes = [];
-  await git.walk({
-    fs: gitFs,
-    dir,
-    cache,
-    trees: [git.WORKDIR(), git.STAGE()],
-    map: async (filepath, [workdir, stage]) => {
-      if (filepath === ".")
-        return;
-      if (!stage && workdir && (filepath.startsWith(".git-damaged") || await git.isIgnored({ fs: gitFs, dir, filepath }))) {
-        return null;
-      }
-      const [wType, sType] = await Promise.all([
-        workdir ? workdir.type() : Promise.resolve(undefined),
-        stage ? stage.type() : Promise.resolve(undefined)
-      ]);
-      if (wType === "tree" || sType === "tree") {
-        if (sType === "blob")
-          removes.push(filepath);
-        else if (wType === "blob")
-          adds.push(filepath);
-        return;
-      }
-      if (wType === "blob" && !sType) {
-        adds.push(filepath);
-      } else if (!wType && sType === "blob") {
-        removes.push(filepath);
-      } else if (wType === "blob" && sType === "blob") {
-        const workdirOid = await workdir.oid();
-        const stageOid = await stage.oid();
-        if (workdirOid !== stageOid) {
-          adds.push(filepath);
-        } else {
-          const fileBytes = await gitFs.promises.readFile(path2.join(dir, filepath));
-          const { oid: actualOid } = await git.hashBlob({ object: fileBytes });
-          if (actualOid !== stageOid)
-            adds.push(filepath);
-        }
-      }
-      return;
-    }
-  });
-  return { adds, removes };
-}
-async function stageChanges(dir, changes, cache) {
-  if (changes.adds.length > 0) {
-    await git.add({ fs: gitFs, dir, cache, filepath: changes.adds });
-  }
-  for (const filepath of changes.removes) {
-    await git.remove({ fs: gitFs, dir, cache, filepath });
-  }
-}
-async function hasPendingChanges(dir, cache = {}) {
-  const { adds, removes } = await listWorkdirChanges(dir, cache);
-  return adds.length > 0 || removes.length > 0;
-}
-async function hasUncommittedChanges(dir, cache = {}) {
-  if (await hasPendingChanges(dir, cache))
-    return true;
-  return !await stageMatchesHead(dir, cache);
-}
-async function stageMatchesHead(dir, cache) {
-  let headOid;
-  try {
-    headOid = await git.resolveRef({ fs: gitFs, dir, ref: "HEAD" });
-  } catch {
-    return false;
-  }
-  let differs = false;
-  await git.walk({
-    fs: gitFs,
-    dir,
-    cache,
-    trees: [git.TREE({ ref: headOid }), git.STAGE()],
-    map: async (filepath, [tree, stage]) => {
-      if (differs || filepath === ".")
-        return differs ? null : undefined;
-      const [tType, sType] = await Promise.all([
-        tree ? tree.type() : Promise.resolve(undefined),
-        stage ? stage.type() : Promise.resolve(undefined)
-      ]);
-      if (tType === "tree" || sType === "tree")
-        return;
-      if (!tType !== !sType) {
-        differs = true;
-        return null;
-      }
-      if (!tType || !sType)
-        return;
-      const [tOid, sOid] = await Promise.all([tree.oid(), stage.oid()]);
-      if (tOid !== sOid)
-        differs = true;
-      return null;
-    }
-  });
-  return !differs;
-}
-
-class LocalFolderSourceProvider {
-  source;
-  capabilities;
-  constructor(source) {
-    this.source = source;
-    this.capabilities = capabilitiesFor(source);
-  }
-  async initVersionHistory(options) {
-    const dir = options.projectDir;
-    if (await findEnclosingRepoDir(dir) !== undefined) {
-      throw new Error("This folder is already inside a versioned book, so gutterpress " + "won't create a separate history here.");
-    }
-    return withRepoLock(dir, async () => {
-      const cache = {};
-      await git.init({ fs: gitFs, dir, defaultBranch: DEFAULT_BRANCH });
-      await stageChanges(dir, await listWorkdirChanges(dir, cache), cache);
-      await git.commit({
-        fs: gitFs,
-        dir,
-        cache,
-        message: options.initialMessage?.trim() || "Created project",
-        author: await resolveGitAuthor(dir, options.authorName, options.authorEmail)
-      });
-      return {
-        type: "local-git-folder",
-        path: dir,
-        repoRoot: dir,
-        subPath: "",
-        hasRemote: false,
-        branch: DEFAULT_BRANCH
-      };
-    });
-  }
-  snapshot() {
-    return Promise.reject(new Error("This book has no version history yet. Enable version history first."));
-  }
-  listHistory() {
-    return Promise.resolve([]);
-  }
-  listHistoryPage() {
-    return Promise.resolve({ entries: [], hasMore: false });
-  }
-  restore() {
-    return Promise.reject(new Error("This book has no version history yet. Enable version history first."));
-  }
-}
-
-class LocalGitSourceProvider {
-  source;
-  capabilities;
-  dir;
-  constructor(source) {
-    this.source = source;
-    this.capabilities = capabilitiesFor(source);
-    this.dir = gitScopeFor(source);
-  }
-  async initVersionHistory(options) {
-    try {
-      await this.snapshot({
-        projectDir: options.projectDir,
-        message: options.initialMessage?.trim() || "Created project",
-        authorName: options.authorName,
-        authorEmail: options.authorEmail
-      });
-    } catch (e) {
-      if (!isNoChangesError(e))
-        throw e;
-    }
-    return this.source;
-  }
-  snapshot(options) {
-    return withRepoLock(this.dir, () => this.snapshotUnlocked(options));
-  }
-  snapshotUnlocked(options) {
-    return snapshotWorkingTreeUnlocked({ ...options, repoRoot: this.dir });
-  }
-  async listHistory(projectDir) {
-    return (await this.listHistoryPage(projectDir)).entries;
-  }
-  async listHistoryPage(_projectDir, options = {}) {
-    const dir = this.dir;
-    const limit = Math.min(500, Math.max(1, options.limit ?? HISTORY_PAGE_LIMIT));
-    const before = options.before;
-    let commits;
-    try {
-      commits = await git.log({
-        fs: gitFs,
-        dir,
-        cache: {},
-        depth: limit + 2,
-        ...before ? { ref: before } : {}
-      });
-    } catch (e) {
-      if (before && e?.code === "NotFoundError") {
-        return { entries: [], hasMore: false };
-      }
-      throw e;
-    }
-    const seen = new Set;
-    let filtered = commits.filter((c) => {
-      if (c.oid === before || seen.has(c.oid))
-        return false;
-      seen.add(c.oid);
-      return true;
-    });
-    const hasMore = filtered.length > limit;
-    if (hasMore)
-      filtered = filtered.slice(0, limit);
-    return {
-      entries: filtered.map((c) => ({
-        id: c.oid,
-        message: c.commit.message.trim(),
-        timestamp: c.commit.author.timestamp * 1000,
-        author: c.commit.author.name
-      })),
-      hasMore
-    };
-  }
-  restore(options) {
-    return withRepoLock(this.dir, () => this.restoreUnlocked(options));
-  }
-  async restoreUnlocked(options) {
-    await git.checkout({
-      fs: gitFs,
-      dir: this.dir,
-      cache: {},
-      ref: options.id,
-      force: true,
-      noUpdateHead: true
-    });
-  }
-}
-async function snapshotWorkingTreeUnlocked(options) {
-  const dir = options.repoRoot ?? options.projectDir;
-  const logger = options.logFile ? createFileLogger(options.logFile, "snapshot") : noopLogger;
-  const cache = options.cache ?? {};
-  const stagingMarker = snapshotStagingMarkerPath(dir);
-  const staleStaging = gitFs.existsSync(stagingMarker);
-  const changes = await listWorkdirChanges(dir, cache);
-  const workdirClean = changes.adds.length === 0 && changes.removes.length === 0;
-  if (workdirClean && !staleStaging) {
-    logger.debug("snapshot", "no changes — skipping");
-    throw new Error("No changes since the last snapshot — there is nothing new to save.");
-  }
-  if (workdirClean && staleStaging && await stageMatchesHead(dir, cache)) {
-    logger.debug("snapshot", "stale marker outlived a completed commit — clearing, not recommitting");
-    gitFs.rmSync(stagingMarker, { force: true });
-    const [head2] = await git.log({ fs: gitFs, dir, cache, depth: 1 });
-    return {
-      id: head2.oid,
-      message: head2.commit.message.trim(),
-      timestamp: head2.commit.author.timestamp * 1000,
-      author: head2.commit.author.name
-    };
-  }
-  logger.info("snapshot", "committing", {
-    adds: changes.adds.length,
-    removes: changes.removes.length,
-    ...staleStaging ? { recoveredStaleStaging: true } : {}
-  });
-  gitFs.writeFileSync(stagingMarker, "");
-  await stageChanges(dir, changes, cache);
-  const author = await resolveGitAuthor(dir, options.authorName, options.authorEmail);
-  const id = await git.commit({
-    fs: gitFs,
-    dir,
-    cache,
-    message: options.message,
-    author
-  });
-  gitFs.rmSync(stagingMarker, { force: true });
-  const [head] = await git.log({ fs: gitFs, dir, cache, depth: 1 });
-  return {
-    id,
-    message: options.message,
-    timestamp: head ? head.commit.author.timestamp * 1000 : Date.now(),
-    author: author.name
-  };
-}
-function isNoChangesError(e) {
-  return e instanceof Error && /no changes since the last snapshot/i.test(e.message);
-}
-function providerFor(source) {
-  switch (source.type) {
-    case "local-folder":
-      return new LocalFolderSourceProvider(source);
-    case "local-git-folder":
-      return new LocalGitSourceProvider(source);
-    case "managed-github":
-      throw new Error("Managed GitHub books are not supported yet (#15/#16).");
-  }
-}
-function gitDirFor(projectDir) {
-  return path2.join(projectDir, ".git");
-}
-function snapshotStagingMarkerPath(projectDir) {
-  return path2.join(gitDirFor(projectDir), SNAPSHOT_STAGING_MARKER);
-}
-var RESTORE_BACKUP_MESSAGE = "Automatic backup before restoring an earlier version";
-var AUTO_SNAPSHOT_MESSAGE = "Automatic snapshot";
-async function restoreVersionWithBackup(options) {
-  const { projectDir, id, authorName, authorEmail } = options;
-  const source = await detectProjectSource(projectDir);
-  if (source.type !== "local-git-folder") {
-    throw new Error("This book has no version history yet. Enable version history first.");
-  }
-  const provider = new LocalGitSourceProvider(source);
-  const repoDir = gitScopeFor(source);
-  return withRepoLock(repoDir, async () => {
-    let backupId;
-    if (await hasPendingChanges(repoDir)) {
-      const backup = await provider.snapshotUnlocked({
-        projectDir,
-        message: RESTORE_BACKUP_MESSAGE,
-        authorName,
-        authorEmail
-      });
-      backupId = backup.id;
-    }
-    try {
-      await provider.restoreUnlocked({ projectDir, id });
-    } catch (cause) {
-      throw new Error(backupId ? "The restore could not be completed, but your work is safe — it was " + `automatically saved as a backup snapshot (${backupId.slice(0, 7)}) ` + "and appears in your version history." : "The restore could not be completed. Your book files were not changed.", { cause });
-    }
-    return { restoredId: id, backupId };
-  });
-}
-var SWITCH_BRANCH_SNAPSHOT_MESSAGE = "Saved before switching copy";
-async function listLocalBranches(dir) {
-  const source = await detectProjectSource(dir);
-  if (source.type !== "local-git-folder")
-    return null;
-  const repoDir = gitScopeFor(source);
-  const [local, current, remotes] = await Promise.all([
-    git.listBranches({ fs: gitFs, dir: repoDir }),
-    git.currentBranch({ fs: gitFs, dir: repoDir, fullname: false }).catch(() => {
-      return;
-    }),
-    git.listRemotes({ fs: gitFs, dir: repoDir }).catch(() => [])
-  ]);
-  const localNames = new Set(local);
-  const remoteOnly = new Set;
-  for (const { remote } of remotes) {
-    const names = await git.listBranches({ fs: gitFs, dir: repoDir, remote }).catch(() => []);
-    for (const name of names) {
-      if (name === "HEAD")
-        continue;
-      if (!localNames.has(name))
-        remoteOnly.add(name);
-    }
-  }
-  return {
-    current: current ?? null,
-    branches: [...localNames, ...remoteOnly].sort(),
-    remoteOnly: [...remoteOnly].sort()
-  };
-}
-async function resolveCopy(repoDir, branch) {
-  const local = await git.resolveRef({ fs: gitFs, dir: repoDir, ref: `refs/heads/${branch}` }).catch(() => {
-    return;
-  });
-  if (local)
-    return { oid: local };
-  const remotes = await git.listRemotes({ fs: gitFs, dir: repoDir }).catch(() => []);
-  for (const { remote } of remotes) {
-    const oid = await git.resolveRef({ fs: gitFs, dir: repoDir, ref: `refs/remotes/${remote}/${branch}` }).catch(() => {
-      return;
-    });
-    if (oid)
-      return { oid, remote };
-  }
-  throw new Error(`Couldn't find a copy named "${branch}" — it may have been renamed or deleted.`);
-}
-function isCheckoutConflictError(e) {
-  return e?.code === "CheckoutConflictError";
-}
-async function diffCommitPaths(dir, fromOid, toOid, cache) {
-  const changed = [];
-  await git.walk({
-    fs: gitFs,
-    dir,
-    cache,
-    trees: [git.TREE({ ref: fromOid }), git.TREE({ ref: toOid })],
-    map: async (filepath, [from, to]) => {
-      if (filepath === ".")
-        return;
-      const [fType, tType] = await Promise.all([
-        from ? from.type() : Promise.resolve(undefined),
-        to ? to.type() : Promise.resolve(undefined)
-      ]);
-      if (fType === "tree" || tType === "tree")
-        return;
-      if (!fType && !tType)
-        return;
-      if (!fType || !tType) {
-        changed.push(filepath);
-        return;
-      }
-      const [fOid, tOid] = await Promise.all([from.oid(), to.oid()]);
-      if (fOid !== tOid)
-        changed.push(filepath);
-    }
-  });
-  return changed;
-}
-async function switchBranch(options) {
-  const { projectDir, branch, authorName, authorEmail } = options;
-  const source = await detectProjectSource(projectDir);
-  if (source.type !== "local-git-folder") {
-    throw new Error("This book has no version history yet. Enable version history first.");
-  }
-  const repoDir = gitScopeFor(source);
-  return withRepoLock(repoDir, async () => {
-    const cache = {};
-    try {
-      await snapshotWorkingTreeUnlocked({
-        projectDir,
-        repoRoot: repoDir,
-        message: SWITCH_BRANCH_SNAPSHOT_MESSAGE,
-        authorName,
-        authorEmail,
-        cache
-      });
-    } catch (e) {
-      if (!isNoChangesError(e))
-        throw e;
-    }
-    const fromOid = await git.resolveRef({ fs: gitFs, dir: repoDir, ref: "HEAD" }).catch(() => {
-      return;
-    });
-    const { oid: toOid, remote } = await resolveCopy(repoDir, branch);
-    try {
-      await git.checkout({
-        fs: gitFs,
-        dir: repoDir,
-        cache,
-        ref: branch,
-        force: false,
-        ...remote ? { remote } : {}
-      });
-    } catch (e) {
-      if (isCheckoutConflictError(e)) {
-        throw new Error("Couldn't switch copies — some files changed on disk right as the switch " + "started. Try again.", { cause: e });
-      }
-      throw e;
-    }
-    const changedPaths = fromOid && fromOid !== toOid ? await diffCommitPaths(repoDir, fromOid, toOid, cache) : [];
-    return {
-      current: branch,
-      changedFiles: changedPaths.map((p) => path2.join(repoDir, p))
-    };
-  });
-}
-
-export { gitFs, errorLogData, resolveLogger, gitScopeFor, HISTORY_PAGE_LIMIT, withRepoLock, __repoLockQueueSizeForTests, resolveGitAuthor, listWorkdirChanges, stageChanges, hasPendingChanges, hasUncommittedChanges, snapshotWorkingTreeUnlocked, isNoChangesError, providerFor, gitDirFor, snapshotStagingMarkerPath, RESTORE_BACKUP_MESSAGE, AUTO_SNAPSHOT_MESSAGE, restoreVersionWithBackup, SWITCH_BRANCH_SNAPSHOT_MESSAGE, listLocalBranches, switchBranch };