@the-open-engine/zeroshot 6.6.0 → 6.7.1

package/scripts/assert-release-published.js

@@ -2,6 +2,9 @@
 
 const { execFileSync } = require('child_process');
 
+const DEFAULT_ATTEMPTS = 24;
+const DEFAULT_DELAY_MS = 5000;
+
 function run(command, args) {
   return execFileSync(command, args, { encoding: 'utf8' }).trim();
 }
@@ -22,32 +25,83 @@ function tagsPointingAtHead() {
     .filter(Boolean);
 }
 
-function main() {
+function releaseTagParts(tag) {
+  const match = tag.match(/^v(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) return null;
+  return match.slice(1).map((part) => Number(part));
+}
+
+function compareReleaseTags(left, right) {
+  const leftParts = releaseTagParts(left);
+  const rightParts = releaseTagParts(right);
+  for (let index = 0; index < leftParts.length; index += 1) {
+    if (leftParts[index] !== rightParts[index]) return leftParts[index] - rightParts[index];
+  }
+  return 0;
+}
+
+function latestReleaseTag(tags) {
+  const releaseTags = tags.filter((tag) => releaseTagParts(tag));
+  releaseTags.sort(compareReleaseTags);
+  return releaseTags.at(-1) || null;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+async function waitForNpmLatest(name, expectedVersion, options = {}) {
+  const attempts =
+    options.attempts || Number(process.env.RELEASE_ASSERT_ATTEMPTS || DEFAULT_ATTEMPTS);
+  const delayMs =
+    options.delayMs || Number(process.env.RELEASE_ASSERT_DELAY_MS || DEFAULT_DELAY_MS);
+
+  let latest = null;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    latest = npmLatest(name);
+    if (latest === expectedVersion) return latest;
+
+    if (attempt < attempts) {
+      console.log(
+        `npm latest for ${name} is ${latest}; waiting for ${expectedVersion} (${attempt}/${attempts})`
+      );
+      await sleep(delayMs);
+    }
+  }
+
+  throw new Error(`expected npm latest for ${name} to be ${expectedVersion}, got ${latest}`);
+}
+
+async function main() {
   const name = packageName();
-  const latest = npmLatest(name);
-  const expectedTag = `v${latest}`;
   const headTags = tagsPointingAtHead();
+  const expectedTag = latestReleaseTag(headTags);
+
+  if (!expectedTag) {
+    throw new Error('expected a vX.Y.Z release tag to point at HEAD after release');
+  }
 
-  console.log(`npm latest for ${name}: ${latest}`);
   console.log(`tags on HEAD: ${headTags.join(', ') || '(none)'}`);
+  const expectedVersion = expectedTag.slice(1);
+  const latest = await waitForNpmLatest(name, expectedVersion);
 
-  if (!headTags.includes(expectedTag)) {
-    throw new Error(`expected ${expectedTag} to point at HEAD after release`);
-  }
+  console.log(`npm latest for ${name}: ${latest}`);
 
   console.log(`Release publication verified: ${name}@${latest}`);
 }
 
 if (require.main === module) {
-  try {
-    main();
-  } catch (error) {
+  main().catch((error) => {
     console.error(`Release publication check failed: ${error.message}`);
     process.exit(1);
-  }
+  });
 }
 
 module.exports = {
+  latestReleaseTag,
   npmLatest,
   tagsPointingAtHead,
+  waitForNpmLatest,
 };

package/scripts/run-lint-staged-no-stash.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const PATCH_NAME = 'lint-staged_unstaged.patch';
+const GIT_APPLY_ARGS = ['apply', '-v', '--whitespace=nowarn', '--recount', '--unidiff-zero'];
+
+function run(command, args, options = {}) {
+  return spawnSync(command, args, {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: options.stdio || 'inherit',
+    encoding: options.encoding,
+  });
+}
+
+function resolveUnstagedPatchPath() {
+  const result = run('git', ['rev-parse', '--git-path', PATCH_NAME], {
+    stdio: 'pipe',
+    encoding: 'utf8',
+  });
+  if (result.status !== 0) return null;
+  const gitPath = result.stdout.trim();
+  return path.isAbsolute(gitPath) ? gitPath : path.resolve(process.cwd(), gitPath);
+}
+
+function restoreUnstagedPatch(patchPath) {
+  const direct = run('git', [...GIT_APPLY_ARGS, patchPath]);
+  if (direct.status === 0) return true;
+
+  const threeWay = run('git', [...GIT_APPLY_ARGS, '--3way', patchPath]);
+  return threeWay.status === 0;
+}
+
+function main() {
+  const patchPath = resolveUnstagedPatchPath();
+  if (patchPath && fs.existsSync(patchPath)) {
+    console.error(
+      `ERROR: Refusing to overwrite unresolved unstaged changes at ${patchPath}.\n` +
+        `Restore them with 'git apply "${patchPath}"', then remove the patch before committing.`
+    );
+    return 1;
+  }
+
+  const lintStagedBin = require.resolve('lint-staged/bin');
+  const lintStaged = run(process.execPath, [lintStagedBin, '--no-stash', ...process.argv.slice(2)]);
+  const lintStatus = lintStaged.status ?? 1;
+
+  if (!patchPath || !fs.existsSync(patchPath)) {
+    return lintStatus;
+  }
+
+  if (lintStatus === 0 || restoreUnstagedPatch(patchPath)) {
+    fs.rmSync(patchPath, { force: true });
+    return lintStatus;
+  }
+
+  console.error(
+    `ERROR: lint-staged failed and unstaged changes conflicted with task edits.\n` +
+      `The commit remains blocked. Your unstaged changes are preserved at ${patchPath}.\n` +
+      `Resolve them with 'git apply --3way "${patchPath}"'; do not delete the patch first.`
+  );
+  return lintStatus;
+}
+
+process.exitCode = main();