screw-up 1.4.0 → 1.6.0

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

@@ -1,11 +1,11 @@
 /*!
  * name: screw-up
- * version: 1.4.0
+ * version: 1.6.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: 48850bae9ed83a921ef5239628983b3e797a0ce7
+ * git.commit.hash: 10c04af9c9b127002592d48cbb6ec18cfe5048bb
  */
 "use strict";
 const fs = require("fs");
@@ -13,6 +13,8 @@ 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) {
@@ -1669,6 +1671,397 @@ 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) => {
+  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;
+        }
+      } 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 true;
+  } catch (e) {
+    return false;
+  }
+};
+const loadCachedTags = async (repoPath) => {
+  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)
+    }
+  };
+  try {
+    await fs$1.writeFile(tempPath, JSON.stringify(data, null, 2), "utf-8");
+    await fs$1.rename(tempPath, cachePath);
+  } catch (error) {
+    try {
+      await fs$1.unlink(tempPath);
+    } catch (e) {
+    }
+    throw error;
+  }
+};
+const reconstructTagCache = (cachedData) => {
+  return {
+    commitToTags: new Map(Object.entries(cachedData.tagCache.commitToTags)),
+    initialized: true
+  };
+};
+const cleanupOldCacheFiles = async (currentCachePath, currentTimestamp) => {
+  let deletedCount = 0;
+  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 filePath = path.join(cacheDir, fileName);
+        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++;
+          }
+        } 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) {
+  }
+  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);
+      }
+    })
+  );
+  return result;
+};
+const buildCompleteTagCache = async (repoPath, parseVersion2) => {
+  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);
+    })
+  );
+  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(
+    `Tag diff: +${diff.added.length} -${diff.deleted.length} =${diff.unchanged.length}`
+  );
+  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
+  };
+}
 const parseVersionComponent = (value) => {
   const num = parseInt(value, 10);
   return num < 0 || num > 65535 ? void 0 : num;
@@ -1794,52 +2187,11 @@ const getCurrentCommit = async (repositoryPath) => {
     return void 0;
   }
 };
-const getRelatedTags = 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}`
-        });
-        let targetCommitOid = tagOid;
-        try {
-          const tagObject = await git__namespace.readTag({
-            fs: fs__namespace,
-            dir: repositoryPath,
-            oid: tagOid
-          });
-          if (tagObject && tagObject.tag.object) {
-            targetCommitOid = tagObject.tag.object;
-          }
-        } catch (e) {
-        }
-        if (targetCommitOid === commitHash) {
-          const version2 = parseVersion(tagName);
-          if (version2 && isValidVersion(version2)) {
-            tagInfos.push({
-              name: tagName,
-              hash: commitHash,
-              version: version2
-            });
-          } else {
-            tagInfos.push({
-              name: tagName,
-              hash: commitHash,
-              version: void 0
-            });
-          }
-        }
-      } catch (e) {
-      }
-    }
-    return tagInfos.sort((a, b) => a.name.localeCompare(b.name));
-  } catch (e) {
+const getRelatedTagsFromCache = (cache, commitHash) => {
+  if (!cache.initialized) {
     return [];
   }
+  return cache.commitToTags.get(commitHash) || [];
 };
 const getRelatedTagsForVersioning = async (repositoryPath, commitHash) => {
   try {
@@ -1852,19 +2204,7 @@ const getRelatedTagsForVersioning = async (repositoryPath, commitHash) => {
           dir: repositoryPath,
           ref: `refs/tags/${tagName}`
         });
-        let targetCommitOid = tagOid;
-        try {
-          const tagObject = await git__namespace.readTag({
-            fs: fs__namespace,
-            dir: repositoryPath,
-            oid: tagOid
-          });
-          if (tagObject && tagObject.tag.object) {
-            targetCommitOid = tagObject.tag.object;
-          }
-        } catch (e) {
-        }
-        if (targetCommitOid === commitHash) {
+        if (tagOid === commitHash) {
           const version2 = parseVersion(tagName);
           if (version2 && isValidVersion(version2)) {
             tagInfos.push({
@@ -1873,6 +2213,25 @@ const getRelatedTagsForVersioning = async (repositoryPath, 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) {
       }
@@ -1922,7 +2281,7 @@ const getModifiedFiles = async (repositoryPath) => {
 const formatModifiedFile = (modifiedFile) => {
   return `'${modifiedFile[0]}':${modifiedFile[1]}:${modifiedFile[2]}:${modifiedFile[3]}`;
 };
-const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits) => {
+const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits, tagCache) => {
   const scheduledStack = [];
   let version2 = { major: 0, minor: 0, build: 1, original: "0.0.1" };
   let currentCommit = commit;
@@ -1931,10 +2290,7 @@ const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits) => {
       version2 = reachedCommits.get(currentCommit.hash);
       break;
     }
-    const relatedTags = await getRelatedTagsForVersioning(
-      cwd,
-      currentCommit.hash
-    );
+    const relatedTags = tagCache ? getRelatedTagsFromCache(tagCache, currentCommit.hash) : await getRelatedTagsForVersioning(cwd, 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;
@@ -1969,7 +2325,8 @@ const lookupVersionLabelRecursive = async (cwd, commit, reachedCommits) => {
         const alternateParentVersion = await lookupVersionLabelRecursive(
           cwd,
           parents[index],
-          reachedCommits
+          reachedCommits,
+          tagCache
         );
         if (alternateParentVersion && compareVersions(alternateParentVersion, version2) < 0) {
           version2 = alternateParentVersion;
@@ -1994,11 +2351,29 @@ const getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logge
     if (!currentCommit) {
       return metadata;
     }
+    const { cache: tagCache, stats } = await loadOrBuildTagCache(
+      gitRootPath,
+      (tagName) => {
+        const version22 = parseVersion(tagName);
+        return version22 && isValidVersion(version22) ? version22 : void 0;
+      },
+      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)`
+      );
+    }
     const reachedCommits = /* @__PURE__ */ new Map();
     let version2 = await lookupVersionLabelRecursive(
       gitRootPath,
       currentCommit,
-      reachedCommits
+      reachedCommits,
+      tagCache
     );
     const gitMetadata = { tags: [], branches: [] };
     metadata.git = gitMetadata;
@@ -2023,7 +2398,7 @@ const getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logge
       date: dayjs(currentCommit.date).format("YYYY-MM-DDTHH:mm:ssZ[Z]"),
       message: currentCommit.message
     };
-    const relatedTags = await getRelatedTags(gitRootPath, currentCommit.hash);
+    const relatedTags = getRelatedTagsFromCache(tagCache, currentCommit.hash);
     gitMetadata.tags = relatedTags.map((tag) => tag.name);
     const relatedBranches = await getRelatedBranches(
       gitRootPath,
@@ -2049,11 +2424,11 @@ const getFetchGitMetadata = (targetDir, checkWorkingDirectoryStatus, logger) =>
   };
 };
 const name = "screw-up";
-const version = "1.4.0";
+const version = "1.6.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 = "48850bae9ed83a921ef5239628983b3e797a0ce7";
+const git_commit_hash = "10c04af9c9b127002592d48cbb6ec18cfe5048bb";
 const packageMetadata = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   author,
@@ -2074,4 +2449,4 @@ exports.replacePeerDependenciesWildcards = replacePeerDependenciesWildcards;
 exports.resolvePackageMetadata = resolvePackageMetadata;
 exports.resolveRawPackageJsonObject = resolveRawPackageJsonObject;
 exports.version = version;
-//# sourceMappingURL=packageMetadata-BR1AdagI.cjs.map
+//# sourceMappingURL=packageMetadata-CCW9p12u.cjs.map