@scalequality/check 0.4.0 → 0.5.1

package/bin/durability/worker.mjs

@@ -0,0 +1,44 @@
+import { realpath } from 'node:fs/promises'
+import { analyzeDurability } from './GitDurabilityEngine.mjs'
+import { ENGINE_COMMIT, validateReport } from './validate.mjs'
+import { runGit, setDeadline, remainingTime, stopGitChildren, GitMeasurementError } from './runtime.mjs'
+
+process.on('SIGTERM', () => { stopGitChildren(); process.exit(2) })
+let completed = false
+process.once('disconnect', () => {
+  if (!completed) { stopGitChildren(); process.exit(2) }
+})
+const send = (message) => { if (process.connected) process.send(message) }
+process.once('message', async ({ root, deadline }) => {
+  try {
+    setDeadline(deadline)
+    if ((await runGit(root, ['rev-parse', '--is-inside-work-tree'])).trim() !== 'true') throw new GitMeasurementError('checkout has no working Git history')
+    const top = (await runGit(root, ['rev-parse', '--show-toplevel'])).trim()
+    if (await realpath(top) !== await realpath(root)) throw new GitMeasurementError('run the check from the repository root to measure Git history')
+    if ((await runGit(root, ['rev-parse', '--is-shallow-repository'])).trim() !== 'false') throw new GitMeasurementError('shallow Git history cannot provide the full 90-day measurement')
+    const partial = await runGit(root, ['config', '--get-regexp', '^(extensions\.partialclone|remote\..*\.promisor)$'], { allowMissingConfig: true })
+    if (partial.split('\n').some(line => /^extensions\.partialclone\s+\S/i.test(line) || /^remote\..*\.promisor\s+(true|yes|on|1)\s*$/i.test(line))) throw new GitMeasurementError('partial Git history cannot be measured without fetching objects')
+    const headSha = (await runGit(root, ['rev-parse', '--verify', 'HEAD'])).trim()
+    if (!/^[0-9a-f]{40}$/.test(headSha)) throw new GitMeasurementError('a valid SHA-1 Git HEAD is required')
+    const objects = await runGit(root, ['rev-list', '--objects', '--no-object-names', '--missing=print', 'HEAD'])
+    if (objects.split('\n').some(line => /^\?[0-9a-f]+$/.test(line))) throw new GitMeasurementError('Git history is missing local objects')
+    const measuredAt = new Date().toISOString()
+    const result = await analyzeDurability(root, {
+      windowDays: 90, settleDays: 14,
+      onLog: message => { remainingTime(); send({ type: 'log', message }) },
+    })
+    remainingTime()
+    if ((await runGit(root, ['rev-parse', '--verify', 'HEAD'])).trim() !== headSha) throw new GitMeasurementError('Git HEAD changed during measurement')
+    const report = { version: 1, source: 'ci', engineCommit: ENGINE_COMMIT, windowDays: 90, settleDays: 14, headSha, measuredAt, result }
+    if (!validateReport(report)) throw new GitMeasurementError('native measurement did not pass report validation')
+    send({ type: 'result', report })
+    completed = true
+    process.disconnect()
+  } catch (error) {
+    send({ type: 'failure', reason: error instanceof GitMeasurementError ? error.reason : 'local Git measurement failed' })
+    stopGitChildren()
+    process.exitCode = 2
+    completed = true
+    if (process.connected) process.disconnect()
+  }
+})

package/bin/durability.mjs

@@ -0,0 +1,65 @@
+import { fork } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { resolve } from 'node:path'
+import { validateReport } from './durability/validate.mjs'
+import { localGitEnvironment } from './durability/runtime.mjs'
+export { ENGINE_COMMIT } from './durability/validate.mjs'
+export const MAX_MEASUREMENT_MS = 120_000
+
+/** Measure committed local history; never clone, fetch, checkout or upload it. */
+export async function measureDurability({ root, log = () => {} }) {
+  const notify = message => { try { log(message) } catch {} }
+  return new Promise(resolveResult => {
+    let worker
+    let result = null
+    let reason = 'local Git measurement failed'
+    let done = false
+    const started = Date.now()
+    const killOwnedGroup = () => {
+      if (!worker?.pid) return
+      try {
+        if (process.platform !== 'win32') process.kill(-worker.pid, 'SIGKILL')
+        else worker.kill('SIGTERM')
+      } catch {}
+    }
+    const finish = value => {
+      if (done) return
+      done = true
+      clearTimeout(timer)
+      process.removeListener('SIGINT', onInterrupt)
+      process.removeListener('SIGTERM', onTerminate)
+      process.removeListener('exit', killOwnedGroup)
+      if (!value) { killOwnedGroup(); notify(`ScaleQuality: Git durability not measured — ${reason}. No Git history was uploaded.`) }
+      resolveResult(value)
+    }
+    const cancel = signal => {
+      const hasOtherHandler = process.listenerCount(signal) > 1
+      reason = 'measurement was cancelled'
+      finish(null)
+      // Preserve the caller's signal handling, including Node's default exit.
+      if (!hasOtherHandler) process.kill(process.pid, signal)
+    }
+    const onInterrupt = () => cancel('SIGINT')
+    const onTerminate = () => cancel('SIGTERM')
+    const timer = setTimeout(() => { reason = 'the 120-second measurement budget was exceeded'; finish(null) }, MAX_MEASUREMENT_MS)
+    process.on('SIGINT', onInterrupt)
+    process.on('SIGTERM', onTerminate)
+    process.on('exit', killOwnedGroup)
+    try {
+      worker = fork(fileURLToPath(new URL('./durability/worker.mjs', import.meta.url)), [], {
+        stdio: ['ignore', 'ignore', 'ignore', 'ipc'], env: localGitEnvironment(),
+        execArgv: ['--max-old-space-size=512'], detached: process.platform !== 'win32',
+      })
+      worker.on('message', message => {
+        if (message?.type === 'log' && typeof message.message === 'string' && /^(commits in window: \d+|blame capped: \d+\/\d+ files \(perf\)|blaming \d+ files\.\.\.)$/.test(message.message)) notify(`ScaleQuality: durability — ${message.message}`)
+        else if (message?.type === 'result' && validateReport(message.report)) result = message.report
+        else if (message?.type === 'failure') reason = typeof message.reason === 'string' ? message.reason : reason
+      })
+      worker.on('error', () => finish(null))
+      worker.on('exit', code => finish(code === 0 && result && validateReport(result) ? result : null))
+      worker.send({ root: resolve(root), deadline: started + MAX_MEASUREMENT_MS - 1000 })
+    } catch { finish(null) }
+  })
+}
+
+export const ENGINE_SOURCE_DIGEST = "bc7a01ce93df3aad2f80da281934868ba7327a1a04fad840f35ecc8b422c74cf"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scalequality/check",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "ScaleQuality continuous code-maturity check for CI. Re-measures your repo on every build and fails the pipeline below your maturity line.",
   "type": "module",
   "bin": {
@@ -26,5 +26,8 @@
   "homepage": "https://scalequality.io",
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
   }
 }