screw-up 1.6.0 → 1.8.0

package/dist/{packageMetadata-CCW9p12u.cjs → packageMetadata-BwTlrgAe.cjs}

@@ -1,11 +1,11 @@
 /*!
  * name: screw-up
- * version: 1.6.0
+ * version: 1.8.0
  * description: Simply package metadata inserter on Vite plugin
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/screw-up.git
- * git.commit.hash: 10c04af9c9b127002592d48cbb6ec18cfe5048bb
+ * git.commit.hash: da96533e5128033ff7a45d59b1cee39e0e819533
  */
 "use strict";
 const fs = require("fs");
@@ -13,8 +13,6 @@ const fs$1 = require("fs/promises");
 const path = require("path");
 const glob = require("glob");
 const git = require("isomorphic-git");
-const crypto = require("crypto");
-const os = require("os");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -1671,397 +1669,195 @@ function requireDayjs_min() {
 }
 var dayjs_minExports = requireDayjs_min();
 const dayjs = /* @__PURE__ */ getDefaultExportFromCjs(dayjs_minExports);
-const CLEANUP_DELETE_AGE_MS = 10 * 24 * 60 * 60 * 1e3;
-const getCachePath = (repoPath) => {
-  const absoluteRepoPath = path.resolve(repoPath);
-  const pathHash = crypto.createHash("sha1").update(absoluteRepoPath).digest("hex");
-  return path.join(
-    os.homedir(),
-    ".cache",
-    "screw-up",
-    "tag-cache",
-    `${pathHash}.json`
-  );
-};
-const buildCacheValidation = async (repoPath) => {
-  const tags = await git__namespace.listTags({ fs: fs$1, dir: repoPath });
-  const tagListHash = crypto.createHash("sha256").update(tags.sort().join("\n")).digest("hex");
-  const validation = {
-    tagListHash,
-    tagCount: tags.length
-  };
-  try {
-    const packedRefsPath = path.join(repoPath, ".git", "packed-refs");
-    const stats = await fs$1.stat(packedRefsPath);
-    validation.packedRefsMtime = stats.mtimeMs;
-  } catch (e) {
-  }
-  try {
-    const refsTagsPath = path.join(repoPath, ".git", "refs", "tags");
-    const stats = await fs$1.stat(refsTagsPath);
-    validation.refsTagsMtime = stats.mtimeMs;
-  } catch (e) {
-  }
-  return validation;
-};
-const isCacheValid = async (cachedData, repoPath) => {
+const parsePackedRefs = async (packedRefsPath) => {
   try {
-    const currentTags = await git__namespace.listTags({ fs: fs$1, dir: repoPath });
-    if (currentTags.length !== cachedData.validation.tagCount) {
-      return false;
-    }
-    const tagListHash = crypto.createHash("sha256").update(currentTags.sort().join("\n")).digest("hex");
-    if (cachedData.validation.tagListHash !== tagListHash) {
-      return false;
-    }
-    if (cachedData.validation.packedRefsMtime !== void 0) {
-      try {
-        const packedRefsPath = path.join(repoPath, ".git", "packed-refs");
-        const stats = await fs$1.stat(packedRefsPath);
-        if (stats.mtimeMs > cachedData.timestamp) {
-          return false;
+    const content = await fs$1.readFile(packedRefsPath, "utf-8");
+    const lines = content.split("\n");
+    const tags = [];
+    for (const line2 of lines) {
+      if (line2.startsWith("#") || !line2.trim()) continue;
+      const match = line2.match(/^[0-9a-f]{40}\s+refs\/tags\/(.+)$/);
+      if (match) {
+        const tagName = match[1];
+        if (!tagName.endsWith("^{}")) {
+          tags.push(tagName);
         }
-      } catch (e) {
       }
     }
-    if (cachedData.validation.refsTagsMtime !== void 0) {
-      try {
-        const refsTagsPath = path.join(repoPath, ".git", "refs", "tags");
-        const stats = await fs$1.stat(refsTagsPath);
-        if (stats.mtimeMs > cachedData.timestamp) {
-          return false;
-        }
-      } catch (e) {
-      }
+    return tags;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
     }
-    return true;
-  } catch (e) {
-    return false;
+    throw error;
   }
 };
-const loadCachedTags = async (repoPath) => {
+const readLooseTags = async (refsTagsPath) => {
   try {
-    const cachePath = getCachePath(repoPath);
-    const data = await fs$1.readFile(cachePath, "utf-8");
-    const cachedData = JSON.parse(data);
-    if (cachedData.version !== "1.0.0") {
-      return null;
-    }
-    return cachedData;
-  } catch (e) {
-    return null;
-  }
-};
-const saveCachedTags = async (repoPath, tagCache, validation) => {
-  const cachePath = getCachePath(repoPath);
-  const cacheDir = path.dirname(cachePath);
-  await fs$1.mkdir(cacheDir, { recursive: true });
-  const randomSuffix = crypto.randomBytes(8).toString("hex");
-  const tempPath = cachePath.replace(".json", `_${randomSuffix}.json`);
-  const data = {
-    version: "1.0.0",
-    timestamp: Date.now(),
-    repository: {
-      path: repoPath
-    },
-    validation,
-    tagCache: {
-      commitToTags: Object.fromEntries(tagCache.commitToTags)
+    const entries = await fs$1.readdir(refsTagsPath, { withFileTypes: true });
+    const tags = [];
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        tags.push(entry.name);
+      }
     }
-  };
-  try {
-    await fs$1.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
-    await fs$1.rename(tempPath, cachePath);
+    return tags;
   } catch (error) {
-    try {
-      await fs$1.unlink(tempPath);
-    } catch (e) {
+    if (error.code === "ENOENT") {
+      return [];
     }
     throw error;
   }
 };
-const reconstructTagCache = (cachedData) => {
-  return {
-    commitToTags: new Map(Object.entries(cachedData.tagCache.commitToTags)),
-    initialized: true
-  };
+const listTagsFast = async (repoPath) => {
+  const gitDir = path.join(repoPath, ".git");
+  const gitStat = await fs$1.stat(gitDir).catch(() => null);
+  let actualGitDir = gitDir;
+  if (gitStat == null ? void 0 : gitStat.isFile()) {
+    const content = await fs$1.readFile(gitDir, "utf-8");
+    const match = content.match(/^gitdir:\s*(.+)$/m);
+    if (match) {
+      actualGitDir = path.isAbsolute(match[1]) ? match[1] : path.join(repoPath, match[1]);
+    }
+  }
+  const [packedTags, looseTags] = await Promise.all([
+    parsePackedRefs(path.join(actualGitDir, "packed-refs")),
+    readLooseTags(path.join(actualGitDir, "refs", "tags"))
+  ]);
+  const allTags = /* @__PURE__ */ new Set([...packedTags, ...looseTags]);
+  return Array.from(allTags).sort();
 };
-const cleanupOldCacheFiles = async (currentCachePath, currentTimestamp) => {
-  let deletedCount = 0;
+const resolveTagsBatchWithCommit = async (repoPath, tagNames, logger) => {
+  const startTime = Date.now();
+  const gitDir = path.join(repoPath, ".git");
+  const result = /* @__PURE__ */ new Map();
+  const gitStat = await fs$1.stat(gitDir).catch(() => null);
+  let actualGitDir = gitDir;
+  if (gitStat == null ? void 0 : gitStat.isFile()) {
+    const content = await fs$1.readFile(gitDir, "utf-8");
+    const match = content.match(/^gitdir:\s*(.+)$/m);
+    if (match) {
+      actualGitDir = path.isAbsolute(match[1]) ? match[1] : path.join(repoPath, match[1]);
+    }
+  }
+  const tagSet = new Set(tagNames);
+  const packedRefsStart = Date.now();
   try {
-    const cacheDir = path.dirname(currentCachePath);
-    const currentFileName = path.basename(currentCachePath);
-    const files = await fs$1.readdir(cacheDir);
-    await Promise.all(
-      files.map(async (fileName) => {
-        if (!fileName.endsWith(".json") || fileName === currentFileName) {
-          return;
+    const content = await fs$1.readFile(
+      path.join(actualGitDir, "packed-refs"),
+      "utf-8"
+    );
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line2 = lines[i];
+      if (line2.startsWith("#") || !line2.trim()) continue;
+      const match = line2.match(/^([0-9a-f]{40})\s+refs\/tags\/(.+)$/);
+      if (match && tagSet.has(match[2])) {
+        const tagName = match[2];
+        const oid = match[1];
+        let commitOid = oid;
+        if (i + 1 < lines.length && lines[i + 1].startsWith("^")) {
+          commitOid = lines[i + 1].substring(1, 41);
         }
-        const filePath = path.join(cacheDir, fileName);
+        result.set(tagName, { oid, commitOid });
+      }
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  logger.debug(
+    `[fast-tags] read packed-refs: ${Date.now() - packedRefsStart}ms`
+  );
+  const remainingTags = tagNames.filter((tag) => !result.has(tag));
+  if (remainingTags.length > 0) {
+    const looseRefsStart = Date.now();
+    await Promise.all(
+      remainingTags.map(async (tagName) => {
+        const looseRefPath = path.join(actualGitDir, "refs", "tags", tagName);
         try {
-          const stats = await fs$1.stat(filePath);
-          const fileAge = currentTimestamp - stats.mtimeMs;
-          if (fileAge > CLEANUP_DELETE_AGE_MS) {
-            await fs$1.unlink(filePath);
-            deletedCount++;
+          const hash = await fs$1.readFile(looseRefPath, "utf-8");
+          const oid = hash.trim();
+          let commitOid = oid;
+          try {
+            const { execSync } = require("child_process");
+            const objectType = execSync(
+              `git -C "${repoPath}" cat-file -t ${oid}`,
+              { encoding: "utf-8" }
+            ).trim();
+            if (objectType === "tag") {
+              const tagContent = execSync(
+                `git -C "${repoPath}" cat-file -p ${oid}`,
+                { encoding: "utf-8" }
+              );
+              const objectMatch = tagContent.match(/^object ([0-9a-f]{40})$/m);
+              if (objectMatch) {
+                commitOid = objectMatch[1];
+              }
+            }
+          } catch (error) {
+            logger.debug(
+              `[fast-tags] Could not determine object type for ${tagName}: ${error}`
+            );
+          }
+          result.set(tagName, { oid, commitOid });
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            throw error;
           }
-        } catch (e) {
         }
       })
     );
-  } catch (e) {
-  }
-  return deletedCount;
-};
-const calculateTagDiff = (cachedTags, currentTagList) => {
-  const cachedTagNames = /* @__PURE__ */ new Set();
-  for (const tags of cachedTags.values()) {
-    for (const tag of tags) {
-      cachedTagNames.add(tag.name);
-    }
-  }
-  const currentSet = new Set(currentTagList);
-  const added = [];
-  const unchanged = [];
-  for (const tagName of currentTagList) {
-    if (cachedTagNames.has(tagName)) {
-      unchanged.push(tagName);
-    } else {
-      added.push(tagName);
-    }
-  }
-  const deleted = [];
-  for (const tagName of cachedTagNames) {
-    if (!currentSet.has(tagName)) {
-      deleted.push(tagName);
-    }
-  }
-  return { added, deleted, unchanged };
-};
-const removeTagsFromCache = (cache, tagNames) => {
-  const tagNamesToRemove = new Set(tagNames);
-  const newCache = /* @__PURE__ */ new Map();
-  for (const [commitHash, tags] of cache.entries()) {
-    const filteredTags = tags.filter((tag) => !tagNamesToRemove.has(tag.name));
-    if (filteredTags.length > 0) {
-      newCache.set(commitHash, filteredTags);
-    }
-  }
-  return newCache;
-};
-const addTagsToCache = (cache, newTags) => {
-  const newCache = new Map(cache);
-  for (const tag of newTags) {
-    const existing = newCache.get(tag.hash) || [];
-    const updated = [...existing, tag];
-    updated.sort((a, b) => a.name.localeCompare(b.name));
-    newCache.set(tag.hash, updated);
-  }
-  return newCache;
-};
-const updateTagsInCache = (cache, tagNames, updatedTags) => {
-  let newCache = removeTagsFromCache(cache, tagNames);
-  newCache = addTagsToCache(newCache, updatedTags);
-  return newCache;
-};
-const resolveTagToCommit = async (repoPath, tagOid) => {
-  var _a;
-  try {
-    const tagObject = await git__namespace.readTag({
-      fs: fs$1,
-      dir: repoPath,
-      oid: tagOid
-    });
-    if ((_a = tagObject == null ? void 0 : tagObject.tag) == null ? void 0 : _a.object) {
-      return tagObject.tag.object;
-    }
-  } catch (e) {
+    logger.debug(
+      `[fast-tags] read loose refs: ${Date.now() - looseRefsStart}ms`
+    );
   }
-  return tagOid;
-};
-const getTagsInfo = async (repoPath, tagNames, parseVersion2) => {
-  const result = [];
-  await Promise.all(
-    tagNames.map(async (tagName) => {
-      try {
-        const oid = await git__namespace.resolveRef({
-          fs: fs$1,
-          dir: repoPath,
-          ref: `refs/tags/${tagName}`
-        });
-        const commitHash = await resolveTagToCommit(repoPath, oid);
-        const version2 = parseVersion2(tagName);
-        result.push({
-          name: tagName,
-          hash: commitHash,
-          version: version2
-        });
-      } catch (error) {
-        console.warn(`Failed to get info for tag ${tagName}:`, error);
-      }
-    })
-  );
+  const totalTime = Date.now() - startTime;
+  logger.debug(`[fast-tags] resolveTagsBatchWithCommit total: ${totalTime}ms`);
+  logger.debug(`[fast-tags] Resolved ${result.size}/${tagNames.length} tags`);
   return result;
 };
-const buildCompleteTagCache = async (repoPath, parseVersion2) => {
+const buildCompleteTagCache = async (repoPath, parseVersion2, logger) => {
+  const totalStart = Date.now();
   const cache = /* @__PURE__ */ new Map();
-  const tags = await git__namespace.listTags({ fs: fs$1, dir: repoPath });
-  await Promise.all(
-    tags.map(async (tagName) => {
-      const oid = await git__namespace.resolveRef({
-        fs: fs$1,
-        dir: repoPath,
-        ref: `refs/tags/${tagName}`
-      });
-      const commitHash = await resolveTagToCommit(repoPath, oid);
-      const version2 = parseVersion2(tagName);
-      const tagInfo = {
-        name: tagName,
-        hash: commitHash,
-        version: version2
-      };
-      if (!cache.has(commitHash)) {
-        cache.set(commitHash, []);
-      }
-      cache.get(commitHash).push(tagInfo);
-    })
+  const listStart = Date.now();
+  const tags = await listTagsFast(repoPath);
+  logger.debug(`[git-ops] listTagsFast: ${Date.now() - listStart}ms`);
+  logger.debug(`[git-ops] Found ${tags.length} tags`);
+  const resolveStart = Date.now();
+  const tagData = await resolveTagsBatchWithCommit(repoPath, tags, logger);
+  logger.debug(
+    `[git-ops] resolveTagsBatchWithCommit: ${Date.now() - resolveStart}ms`
   );
+  const buildStart = Date.now();
+  for (const tagName of tags) {
+    const data = tagData.get(tagName);
+    if (!data) continue;
+    const { commitOid } = data;
+    const version2 = parseVersion2(tagName);
+    const tagInfo = {
+      name: tagName,
+      hash: commitOid,
+      version: version2
+    };
+    if (!cache.has(commitOid)) {
+      cache.set(commitOid, []);
+    }
+    cache.get(commitOid).push(tagInfo);
+  }
+  logger.debug(`[git-ops] build cache map: ${Date.now() - buildStart}ms`);
+  const sortStart = Date.now();
   for (const tags2 of cache.values()) {
     tags2.sort((a, b) => a.name.localeCompare(b.name));
   }
-  return cache;
-};
-const hasTagMoved = async (repoPath, tagName, cachedCommit) => {
-  try {
-    const oid = await git__namespace.resolveRef({
-      fs: fs$1,
-      dir: repoPath,
-      ref: `refs/tags/${tagName}`
-    });
-    const currentCommit = await resolveTagToCommit(repoPath, oid);
-    return currentCommit !== cachedCommit;
-  } catch (e) {
-    return true;
-  }
-};
-const findModifiedTags = async (repoPath, tagNames, cache) => {
-  const modified = [];
-  await Promise.all(
-    tagNames.map(async (tagName) => {
-      let cachedCommit;
-      for (const [commit, tags] of cache.entries()) {
-        const tag = tags.find((t) => t.name === tagName);
-        if (tag) {
-          cachedCommit = commit;
-          break;
-        }
-      }
-      if (cachedCommit) {
-        const moved = await hasTagMoved(repoPath, tagName, cachedCommit);
-        if (moved) {
-          modified.push(tagName);
-        }
-      }
-    })
-  );
-  return modified;
-};
-const loadOrBuildTagCache = async (repoPath, parseVersion2, logger) => {
-  const startTime = Date.now();
-  const cachedData = await loadCachedTags(repoPath);
-  const currentTags = await git__namespace.listTags({ fs: fs$1, dir: repoPath });
-  if (cachedData && await isCacheValid(cachedData, repoPath)) {
-    logger.debug(`Cache valid, performing differential update...`);
-    const cache = reconstructTagCache(cachedData);
-    const stats = await performDifferentialUpdate(
-      repoPath,
-      cache.commitToTags,
-      currentTags,
-      parseVersion2,
-      logger
-    );
-    const validation = await buildCacheValidation(repoPath);
-    await saveCachedTags(repoPath, cache, validation);
-    if (cachedData && Date.now() - cachedData.timestamp > 24 * 60 * 60 * 1e3) {
-      try {
-        const cachePath = getCachePath(repoPath);
-        const deletedCount = await cleanupOldCacheFiles(cachePath, Date.now());
-        if (deletedCount > 0) {
-          logger.debug(`Cleaned up ${deletedCount} old cache files`);
-        }
-      } catch (e) {
-      }
-    }
-    return {
-      cache,
-      stats: {
-        ...stats,
-        updateTime: Date.now() - startTime,
-        fullRebuild: false
-      }
-    };
-  } else {
-    logger.debug(`Cache invalid or missing, building from scratch...`);
-    const commitToTags = await buildCompleteTagCache(repoPath, parseVersion2);
-    const cache = {
-      commitToTags,
-      initialized: true
-    };
-    const validation = await buildCacheValidation(repoPath);
-    await saveCachedTags(repoPath, cache, validation);
-    return {
-      cache,
-      stats: {
-        added: currentTags.length,
-        deleted: 0,
-        modified: 0,
-        unchanged: 0,
-        totalTags: currentTags.length,
-        updateTime: Date.now() - startTime,
-        fullRebuild: true
-      }
-    };
-  }
-};
-async function performDifferentialUpdate(repoPath, cache, currentTags, parseVersion2, logger) {
-  const diff = calculateTagDiff(cache, currentTags);
+  logger.debug(`[git-ops] sort tags: ${Date.now() - sortStart}ms`);
   logger.debug(
-    `Tag diff: +${diff.added.length} -${diff.deleted.length} =${diff.unchanged.length}`
+    `[git-ops] buildCompleteTagCache total: ${Date.now() - totalStart}ms`
   );
-  const modified = await findModifiedTags(repoPath, diff.unchanged, cache);
-  logger.debug(`Found ${modified.length} modified tags`);
-  if (diff.deleted.length > 0) {
-    const newCache = removeTagsFromCache(cache, diff.deleted);
-    cache.clear();
-    for (const [k, v] of newCache) {
-      cache.set(k, v);
-    }
-  }
-  if (diff.added.length > 0) {
-    const newTags = await getTagsInfo(repoPath, diff.added, parseVersion2);
-    const newCache = addTagsToCache(cache, newTags);
-    cache.clear();
-    for (const [k, v] of newCache) {
-      cache.set(k, v);
-    }
-  }
-  if (modified.length > 0) {
-    const updatedTags = await getTagsInfo(repoPath, modified, parseVersion2);
-    const newCache = updateTagsInCache(cache, modified, updatedTags);
-    cache.clear();
-    for (const [k, v] of newCache) {
-      cache.set(k, v);
-    }
-  }
-  const unchangedCount = diff.unchanged.length - modified.length;
-  return {
-    added: diff.added.length,
-    deleted: diff.deleted.length,
-    modified: modified.length,
-    unchanged: unchangedCount,
-    totalTags: currentTags.length
-  };
-}
+  logger.debug(`[git-ops] Built cache with ${cache.size} unique commits`);
+  return cache;
+};
 const parseVersionComponent = (value) => {
   const num = parseInt(value, 10);
   return num < 0 || num > 65535 ? void 0 : num;
@@ -2187,59 +1983,8 @@ const getCurrentCommit = async (repositoryPath) => {
     return void 0;
   }
 };
-const getRelatedTagsFromCache = (cache, commitHash) => {
-  if (!cache.initialized) {
-    return [];
-  }
-  return cache.commitToTags.get(commitHash) || [];
-};
-const getRelatedTagsForVersioning = async (repositoryPath, commitHash) => {
-  try {
-    const tags = await git__namespace.listTags({ fs: fs__namespace, dir: repositoryPath });
-    const tagInfos = [];
-    for (const tagName of tags) {
-      try {
-        const tagOid = await git__namespace.resolveRef({
-          fs: fs__namespace,
-          dir: repositoryPath,
-          ref: `refs/tags/${tagName}`
-        });
-        if (tagOid === commitHash) {
-          const version2 = parseVersion(tagName);
-          if (version2 && isValidVersion(version2)) {
-            tagInfos.push({
-              name: tagName,
-              hash: commitHash,
-              version: version2
-            });
-          }
-        } else {
-          try {
-            const tagObject = await git__namespace.readTag({
-              fs: fs__namespace,
-              dir: repositoryPath,
-              oid: tagOid
-            });
-            if (tagObject && tagObject.tag.object === commitHash) {
-              const version2 = parseVersion(tagName);
-              if (version2 && isValidVersion(version2)) {
-                tagInfos.push({
-                  name: tagName,
-                  hash: commitHash,
-                  version: version2
-                });
-              }
-            }
-          } catch (e) {
-          }
-        }
-      } catch (e) {
-      }
-    }
-    return tagInfos;
-  } catch (e) {
-    return [];
-  }
+const getRelatedTagsFromMap = (commitToTags, commitHash) => {
+  return commitToTags.get(commitHash) || [];
 };
 const getRelatedBranches = async (repositoryPath, commitHash) => {
   try {
@@ -2281,7 +2026,7 @@ const getModifiedFiles = async (repositoryPath) => {
 const formatModifiedFile = (modifiedFile) => {
   return `'${modifiedFile[0]}':${modifiedFile[1]}:${modifiedFile[2]}:${modifiedFile[3]}`;
 };
-const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, tagCache) => {
+const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, commitToTags) => {
   const scheduledStack = [];
   let version2 = { major: 0, minor: 0, build: 1, original: "0.0.1" };
   let currentCommit = commit;
@@ -2290,7 +2035,7 @@ const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, tagCache
       version2 = reachedCommits.get(currentCommit.hash);
       break;
     }
-    const relatedTags = tagCache ? getRelatedTagsFromCache(tagCache, currentCommit.hash) : await getRelatedTagsForVersioning(cwd, currentCommit.hash);
+    const relatedTags = getRelatedTagsFromMap(commitToTags, currentCommit.hash);
     const versionCandidates = relatedTags.filter((tag) => tag.version && isValidVersion(tag.version)).filter((tag) => tag.version.minor !== void 0).sort((a, b) => compareVersions(a.version, b.version));
     if (versionCandidates.length >= 1) {
       version2 = versionCandidates[0].version;
@@ -2326,7 +2071,7 @@ const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, tagCache
           cwd,
           parents[index],
           reachedCommits,
-          tagCache
+          commitToTags
         );
         if (alternateParentVersion && compareVersions(alternateParentVersion, version2) < 0) {
           version2 = alternateParentVersion;
@@ -2339,19 +2084,27 @@ const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, tagCache
   return version2;
 };
 const getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logger) => {
+  const startTime = Date.now();
   const metadata = {};
   let gitRootPath;
   try {
     gitRootPath = await git__namespace.findRoot({ fs: fs__namespace, filepath: repositoryPath });
   } catch (e) {
+    logger.debug(
+      `[screw-up] Total getGitMetadata: ${Date.now() - startTime}ms`
+    );
     return metadata;
   }
   try {
     const currentCommit = await getCurrentCommit(gitRootPath);
     if (!currentCommit) {
+      logger.debug(
+        `[screw-up] Total getGitMetadata: ${Date.now() - startTime}ms`
+      );
       return metadata;
     }
-    const { cache: tagCache, stats } = await loadOrBuildTagCache(
+    const buildStart = Date.now();
+    const commitToTags = await buildCompleteTagCache(
       gitRootPath,
       (tagName) => {
         const version22 = parseVersion(tagName);
@@ -2359,21 +2112,16 @@ const getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logge
       },
       logger
     );
-    if (stats.fullRebuild) {
-      logger.debug(
-        `Built new tag cache: ${stats.totalTags} tags in ${stats.updateTime}ms`
-      );
-    } else {
-      logger.debug(
-        `Updated cache differentially: +${stats.added} -${stats.deleted} ~${stats.modified} =${stats.unchanged} (${stats.updateTime}ms)`
-      );
-    }
+    logger.debug(
+      `[screw-up] buildCompleteTagCache: ${Date.now() - buildStart}ms`
+    );
+    logger.debug(`Built tag map with ${commitToTags.size} commits`);
     const reachedCommits = /* @__PURE__ */ new Map();
     let version2 = await lookupVersionLabelRecursive(
       gitRootPath,
       currentCommit,
       reachedCommits,
-      tagCache
+      commitToTags
     );
     const gitMetadata = { tags: [], branches: [] };
     metadata.git = gitMetadata;
@@ -2398,7 +2146,7 @@ const getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logge
       date: dayjs(currentCommit.date).format("YYYY-MM-DDTHH:mm:ssZ[Z]"),
       message: currentCommit.message
     };
-    const relatedTags = getRelatedTagsFromCache(tagCache, currentCommit.hash);
+    const relatedTags = getRelatedTagsFromMap(commitToTags, currentCommit.hash);
     gitMetadata.tags = relatedTags.map((tag) => tag.name);
     const relatedBranches = await getRelatedBranches(
       gitRootPath,
@@ -2408,6 +2156,7 @@ const getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logge
   } catch (error) {
     logger.warn(`Failed to extract git metadata: ${error}`);
   }
+  logger.debug(`[screw-up] Total getGitMetadata: ${Date.now() - startTime}ms`);
   return metadata;
 };
 const getFetchGitMetadata = (targetDir, checkWorkingDirectoryStatus, logger) => {
@@ -2424,11 +2173,11 @@ const getFetchGitMetadata = (targetDir, checkWorkingDirectoryStatus, logger) =>
   };
 };
 const name = "screw-up";
-const version = "1.6.0";
+const version = "1.8.0";
 const author = "Kouji Matsui (@kekyo@mi.kekyo.net)";
 const license = "MIT";
 const repository_url = "https://github.com/kekyo/screw-up.git";
-const git_commit_hash = "10c04af9c9b127002592d48cbb6ec18cfe5048bb";
+const git_commit_hash = "da96533e5128033ff7a45d59b1cee39e0e819533";
 const packageMetadata = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   author,
@@ -2449,4 +2198,4 @@ exports.replacePeerDependenciesWildcards = replacePeerDependenciesWildcards;
 exports.resolvePackageMetadata = resolvePackageMetadata;
 exports.resolveRawPackageJsonObject = resolveRawPackageJsonObject;
 exports.version = version;
-//# sourceMappingURL=packageMetadata-CCW9p12u.cjs.map
+//# sourceMappingURL=packageMetadata-BwTlrgAe.cjs.map