screw-up 1.5.0 → 1.6.0

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

@@ -1,11 +1,11 @@
 /*!
  * name: screw-up
- * version: 1.5.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: 72fd5b88656bc400ba3fed500895826208e23217
+ * 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,67 +2187,6 @@ const getCurrentCommit = async (repositoryPath) => {
     return void 0;
   }
 };
-const buildTagCache = async (repositoryPath) => {
-  const cache = {
-    commitToTags: /* @__PURE__ */ new Map(),
-    initialized: true
-  };
-  try {
-    const tags = await git__namespace.listTags({ fs: fs__namespace, dir: repositoryPath });
-    await Promise.all(
-      tags.map(async (tagName) => {
-        try {
-          const tagOid = await git__namespace.resolveRef({
-            fs: fs__namespace,
-            dir: repositoryPath,
-            ref: `refs/tags/${tagName}`
-          });
-          const version2 = parseVersion(tagName);
-          const tagInfo = {
-            name: tagName,
-            hash: tagOid,
-            // This will be updated for annotated tags
-            version: version2 && isValidVersion(version2) ? version2 : void 0
-          };
-          if (!cache.commitToTags.has(tagOid)) {
-            cache.commitToTags.set(tagOid, []);
-          }
-          cache.commitToTags.get(tagOid).push({ ...tagInfo, hash: tagOid });
-          try {
-            const tagObject = await git__namespace.readTag({
-              fs: fs__namespace,
-              dir: repositoryPath,
-              oid: tagOid
-            });
-            if (tagObject && tagObject.tag.object) {
-              const commitOid = tagObject.tag.object;
-              const lightweightTags = cache.commitToTags.get(tagOid);
-              if (lightweightTags) {
-                const index = lightweightTags.findIndex(
-                  (t) => t.name === tagName
-                );
-                if (index >= 0) {
-                  lightweightTags.splice(index, 1);
-                  if (lightweightTags.length === 0) {
-                    cache.commitToTags.delete(tagOid);
-                  }
-                }
-              }
-              if (!cache.commitToTags.has(commitOid)) {
-                cache.commitToTags.set(commitOid, []);
-              }
-              cache.commitToTags.get(commitOid).push({ ...tagInfo, hash: commitOid });
-            }
-          } catch (e) {
-          }
-        } catch (e) {
-        }
-      })
-    );
-  } catch (e) {
-  }
-  return cache;
-};
 const getRelatedTagsFromCache = (cache, commitHash) => {
   if (!cache.initialized) {
     return [];
@@ -2019,10 +2351,23 @@ const getGitMetadata = async (repositoryPath, checkWorkingDirectoryStatus, logge
     if (!currentCommit) {
       return metadata;
     }
-    const tagCache = await buildTagCache(gitRootPath);
-    logger.debug(
-      `Built tag cache with ${tagCache.commitToTags.size} commit entries`
+    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,
@@ -2079,11 +2424,11 @@ const getFetchGitMetadata = (targetDir, checkWorkingDirectoryStatus, logger) =>
   };
 };
 const name = "screw-up";
-const version = "1.5.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 = "72fd5b88656bc400ba3fed500895826208e23217";
+const git_commit_hash = "10c04af9c9b127002592d48cbb6ec18cfe5048bb";
 const packageMetadata = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   author,
@@ -2104,4 +2449,4 @@ exports.replacePeerDependenciesWildcards = replacePeerDependenciesWildcards;
 exports.resolvePackageMetadata = resolvePackageMetadata;
 exports.resolveRawPackageJsonObject = resolveRawPackageJsonObject;
 exports.version = version;
-//# sourceMappingURL=packageMetadata-CbqTWPYD.cjs.map
+//# sourceMappingURL=packageMetadata-CCW9p12u.cjs.map