@imdeadpool/guardex 7.0.22 → 7.0.24

package/src/report/session-severity.js

@@ -0,0 +1,282 @@
+const TASK_SIZE_UPPER_BOUNDS = {
+  'narrow-patch': 1_800_000,
+  'medium-change': 4_000_000,
+  'large-change': 8_000_000,
+};
+
+const TASK_SIZE_VALUES = Object.keys(TASK_SIZE_UPPER_BOUNDS);
+const TASK_SIZE_SET = new Set(TASK_SIZE_VALUES);
+const FRAGMENTATION_PRESET_SCORES = {
+  clean: 0,
+  'few-extra-checks': 5,
+  'repeated-follow-ups': 10,
+  looping: 18,
+  'dominant-loop': 25,
+};
+const FINISH_PATH_PRESET_SCORES = {
+  'clear-early': 0,
+  'minor-hesitation': 5,
+  'late-decision': 10,
+  reopening: 15,
+};
+const POST_PROOF_PRESET_SCORES = {
+  'stops-soon': 0,
+  'small-tail': 5,
+  'notable-tail': 10,
+  'heavy-tail': 15,
+};
+const DRIVER_TIE_BREAK = ['fragmentation', 'writeStdin', 'finishPath', 'postProof', 'cost'];
+const DRIVER_LABELS = {
+  cost: 'cost vs expected scope',
+  fragmentation: 'turn fragmentation',
+  writeStdin: 'write_stdin churn',
+  finishPath: 'finish-path discipline',
+  postProof: 'post-proof drift',
+};
+const LABEL_BANDS = [
+  { max: 15, label: 'Healthy' },
+  { max: 30, label: 'Mildly fragmented' },
+  { max: 50, label: 'Inefficient' },
+  { max: 75, label: 'Runaway' },
+  { max: 100, label: 'Catastrophic' },
+];
+const SESSION_SEVERITY_SUBCOMMAND = 'session-severity';
+const SESSION_SEVERITY_USAGE_ARGS = [
+  `--task-size <${TASK_SIZE_VALUES.join('|')}>`,
+  '--tokens <count>',
+  '--exec-count <count>',
+  '--write-stdin-count <count>',
+  '--completion-before-tail <yes|no>',
+  '[--expected-bound <count>]',
+  `[--fragmentation <${Object.keys(FRAGMENTATION_PRESET_SCORES).join('|')}|0-25>]`,
+  `[--finish-path <${Object.keys(FINISH_PATH_PRESET_SCORES).join('|')}|0-15>]`,
+  `[--post-proof <${Object.keys(POST_PROOF_PRESET_SCORES).join('|')}|0-15>]`,
+  '[--json]',
+].join(' ');
+const SESSION_SEVERITY_COMMAND_TAIL = `${SESSION_SEVERITY_SUBCOMMAND} ${SESSION_SEVERITY_USAGE_ARGS}`;
+const SESSION_SEVERITY_EXAMPLE_ARGS = [
+  '--task-size',
+  'narrow-patch',
+  '--tokens',
+  '3850000',
+  '--exec-count',
+  '18',
+  '--write-stdin-count',
+  '6',
+  '--completion-before-tail',
+  'yes',
+  '--fragmentation',
+  '14',
+  '--finish-path',
+  '6',
+  '--post-proof',
+  '4',
+];
+const SESSION_SEVERITY_EXAMPLE_TAIL = `${SESSION_SEVERITY_SUBCOMMAND} ${SESSION_SEVERITY_EXAMPLE_ARGS.join(' ')}`;
+
+function formatInteger(value) {
+  return Number(value).toLocaleString('en-US');
+}
+
+function parseRequiredPositiveInteger(name, rawValue, { allowZero = true } = {}) {
+  const parsed = Number.parseInt(String(rawValue || ''), 10);
+  if (!Number.isFinite(parsed) || (!allowZero && parsed <= 0) || (allowZero && parsed < 0)) {
+    throw new Error(`${name} requires ${allowZero ? 'a non-negative integer' : 'a positive integer'} value`);
+  }
+  return parsed;
+}
+
+function parseBooleanFlag(name, rawValue) {
+  const normalized = String(rawValue || '').trim().toLowerCase();
+  if (normalized === 'yes' || normalized === 'true' || normalized === '1') {
+    return true;
+  }
+  if (normalized === 'no' || normalized === 'false' || normalized === '0') {
+    return false;
+  }
+  throw new Error(`${name} requires yes/no (or true/false, 1/0)`);
+}
+
+function clampScore(value, min, max) {
+  return Math.max(min, Math.min(max, Math.round(value)));
+}
+
+function parseTaskSize(rawTaskSize) {
+  const normalized = String(rawTaskSize || '').trim();
+  if (!TASK_SIZE_SET.has(normalized)) {
+    throw new Error(`--task-size must be one of: ${TASK_SIZE_VALUES.join(', ')}`);
+  }
+  return normalized;
+}
+
+function resolveExpectedUpperBound(taskSize, rawExpectedBound) {
+  if (rawExpectedBound) {
+    return parseRequiredPositiveInteger('--expected-bound', rawExpectedBound, { allowZero: false });
+  }
+  return TASK_SIZE_UPPER_BOUNDS[taskSize];
+}
+
+function scoreCost(tokens, expectedUpperBound) {
+  const ratio = tokens / expectedUpperBound;
+  if (ratio <= 1.0) return 0;
+  if (ratio <= 1.5) return 5;
+  if (ratio <= 2.5) return 10;
+  if (ratio <= 4.0) return 18;
+  if (ratio <= 6.0) return 24;
+  return 30;
+}
+
+function scoreFragmentation(execCount, override) {
+  if (override) {
+    if (Object.prototype.hasOwnProperty.call(FRAGMENTATION_PRESET_SCORES, override)) {
+      return FRAGMENTATION_PRESET_SCORES[override];
+    }
+    return clampScore(parseRequiredPositiveInteger('--fragmentation', override), 0, 25);
+  }
+  if (execCount <= 4) return 0;
+  if (execCount <= 8) return 5;
+  if (execCount <= 16) return 10;
+  if (execCount <= 28) return 18;
+  return 25;
+}
+
+function scoreWriteStdin(writeStdinCount) {
+  if (writeStdinCount <= 0) return 0;
+  if (writeStdinCount <= 3) return 5;
+  if (writeStdinCount <= 6) return 10;
+  return 15;
+}
+
+function scoreFinishPath(completionBeforeTail, override) {
+  if (override) {
+    if (Object.prototype.hasOwnProperty.call(FINISH_PATH_PRESET_SCORES, override)) {
+      return FINISH_PATH_PRESET_SCORES[override];
+    }
+    return clampScore(parseRequiredPositiveInteger('--finish-path', override), 0, 15);
+  }
+  return completionBeforeTail ? 0 : 5;
+}
+
+function scorePostProof(completionBeforeTail, override) {
+  if (override) {
+    if (Object.prototype.hasOwnProperty.call(POST_PROOF_PRESET_SCORES, override)) {
+      return POST_PROOF_PRESET_SCORES[override];
+    }
+    return clampScore(parseRequiredPositiveInteger('--post-proof', override), 0, 15);
+  }
+  return completionBeforeTail ? 0 : 10;
+}
+
+function labelForTotal(total) {
+  return LABEL_BANDS.find((band) => total <= band.max)?.label || LABEL_BANDS[LABEL_BANDS.length - 1].label;
+}
+
+function buildSessionSeverityReport(options) {
+  const taskSize = parseTaskSize(options.taskSize);
+  const tokens = parseRequiredPositiveInteger('--tokens', options.tokens);
+  const execCount = parseRequiredPositiveInteger('--exec-count', options.execCount);
+  const writeStdinCount = parseRequiredPositiveInteger('--write-stdin-count', options.writeStdinCount);
+  const completionBeforeTail = parseBooleanFlag('--completion-before-tail', options.completionBeforeTail);
+  const expectedUpperBound = resolveExpectedUpperBound(taskSize, options.expectedBound);
+  const costRatio = tokens / expectedUpperBound;
+  const scores = {
+    cost: scoreCost(tokens, expectedUpperBound),
+    fragmentation: scoreFragmentation(execCount, options.fragmentation),
+    writeStdin: scoreWriteStdin(writeStdinCount),
+    finishPath: scoreFinishPath(completionBeforeTail, options.finishPath),
+    postProof: scorePostProof(completionBeforeTail, options.postProof),
+  };
+  const total = scores.cost + scores.fragmentation + scores.writeStdin + scores.finishPath + scores.postProof;
+  const label = labelForTotal(total);
+  const rankedDimensions = Object.entries(scores)
+    .map(([key, score]) => ({ key, score, label: DRIVER_LABELS[key] }))
+    .filter((entry) => entry.score > 0)
+    .sort((left, right) => {
+      if (right.score !== left.score) {
+        return right.score - left.score;
+      }
+      return DRIVER_TIE_BREAK.indexOf(left.key) - DRIVER_TIE_BREAK.indexOf(right.key);
+    });
+  const primaryDriver = rankedDimensions[0] ? rankedDimensions[0].label : 'none';
+  const secondaries = rankedDimensions.slice(1).map((entry) => entry.label);
+
+  return {
+    taskSize,
+    expectedUpperBound,
+    tokens,
+    execCount,
+    writeStdinCount,
+    completionBeforeTail,
+    costRatio,
+    scores: {
+      ...scores,
+      total,
+    },
+    label,
+    primaryDriver,
+    secondaries,
+    outputLine: `Score ${total}/100 — ${label}. Primary: ${primaryDriver}. Secondaries: ${
+      secondaries.length > 0 ? secondaries.join(', ') : 'none'
+    }.`,
+  };
+}
+
+function renderSessionSeverityReport(report) {
+  return [
+    report.outputLine,
+    '',
+    `Task size: ${report.taskSize}`,
+    `Expected upper bound: ${report.expectedUpperBound}`,
+    `Actual tokens: ${report.tokens}`,
+    `Exec count: ${report.execCount}`,
+    `write_stdin count: ${report.writeStdinCount}`,
+    `Completion before tail churn: ${report.completionBeforeTail ? 'yes' : 'no'}`,
+    `Cost ratio: ${report.costRatio.toFixed(2)}x`,
+    '',
+    `A. Cost vs expected scope: ${report.scores.cost}`,
+    `B. Turn fragmentation: ${report.scores.fragmentation}`,
+    `C. write_stdin churn: ${report.scores.writeStdin}`,
+    `D. Finish-path discipline: ${report.scores.finishPath}`,
+    `E. Post-proof drift: ${report.scores.postProof}`,
+    '',
+    `Total: ${report.scores.total}`,
+    `Label: ${report.label}`,
+    `Primary driver: ${report.primaryDriver}`,
+    `Secondary drivers: ${report.secondaries.length > 0 ? report.secondaries.join(', ') : 'none'}`,
+  ].join('\n');
+}
+
+function renderSessionSeverityHelpDetails() {
+  const taskSizeDefaults = TASK_SIZE_VALUES
+    .map((taskSize) => `${taskSize}=${formatInteger(TASK_SIZE_UPPER_BOUNDS[taskSize])}`)
+    .join(', ');
+  const labelBands = LABEL_BANDS
+    .map((band, index) => {
+      const min = index === 0 ? 0 : LABEL_BANDS[index - 1].max + 1;
+      return `${band.label}=${min}-${band.max}`;
+    })
+    .join(', ');
+  return [`Task-size defaults: ${taskSizeDefaults}`, `Label bands: ${labelBands}`].join('\n');
+}
+
+function renderSessionSeverityCommand(toolName) {
+  return `${toolName} report ${SESSION_SEVERITY_COMMAND_TAIL}`;
+}
+
+function renderSessionSeverityExample(toolName) {
+  return `${toolName} report ${SESSION_SEVERITY_EXAMPLE_TAIL}`;
+}
+
+module.exports = {
+  LABEL_BANDS,
+  SESSION_SEVERITY_COMMAND_TAIL,
+  SESSION_SEVERITY_EXAMPLE_ARGS,
+  SESSION_SEVERITY_EXAMPLE_TAIL,
+  TASK_SIZE_UPPER_BOUNDS,
+  buildSessionSeverityReport,
+  renderSessionSeverityReport,
+  renderSessionSeverityHelpDetails,
+  renderSessionSeverityCommand,
+  renderSessionSeverityExample,
+  labelForTotal,
+};

package/src/scaffold/index.js

@@ -1,6 +1,7 @@
 const {
   fs,
   path,
+  PACKAGE_ROOT,
   TOOL_NAME,
   SHORT_TOOL_NAME,
   GUARDEX_HOME_DIR,
@@ -9,6 +10,7 @@ const {
   HOOK_NAMES,
   LOCK_FILE_RELATIVE,
   LEGACY_MANAGED_PACKAGE_SCRIPTS,
+  PACKAGE_ROOT_SOURCE_OVERRIDES,
   USER_LEVEL_SKILL_ASSETS,
   AGENTS_MARKER_START,
   AGENTS_MARKER_END,
@@ -24,6 +26,7 @@ const {
   EXECUTABLE_RELATIVE_PATHS,
   CRITICAL_GUARDRAIL_PATHS,
 } = require('../context');
+const { parse: parseJsonc, printParseErrorCode } = require('jsonc-parser');
 const { run } = require('../core/runtime');
 
 function ensureParentDir(repoRoot, filePath, dryRun) {
@@ -172,17 +175,13 @@ function ensureHookShim(repoRoot, hookName, options = {}) {
   );
 }
 
-function copyTemplateFile(repoRoot, relativeTemplatePath, force, dryRun) {
-  const sourcePath = path.join(TEMPLATE_ROOT, relativeTemplatePath);
-  const destinationRelativePath = toDestinationPath(relativeTemplatePath);
-  const destinationPath = path.join(repoRoot, destinationRelativePath);
-
-  const sourceContent = fs.readFileSync(sourcePath, 'utf8');
+function copyManagedSourceFile(repoRoot, sourcePath, destinationPath, destinationRelativePath, force, dryRun) {
+  const sourceContent = fs.readFileSync(sourcePath);
   const destinationExists = fs.existsSync(destinationPath);
 
   if (destinationExists) {
-    const existingContent = fs.readFileSync(destinationPath, 'utf8');
-    if (existingContent === sourceContent) {
+    const existingContent = fs.readFileSync(destinationPath);
+    if (existingContent.equals(sourceContent)) {
       ensureExecutable(destinationPath, destinationRelativePath, dryRun);
       return { status: 'unchanged', file: destinationRelativePath };
     }
@@ -193,7 +192,7 @@ function copyTemplateFile(repoRoot, relativeTemplatePath, force, dryRun) {
 
   ensureParentDir(repoRoot, destinationPath, dryRun);
   if (!dryRun) {
-    fs.writeFileSync(destinationPath, sourceContent, 'utf8');
+    fs.writeFileSync(destinationPath, sourceContent);
     ensureExecutable(destinationPath, destinationRelativePath, dryRun);
   }
 
@@ -204,22 +203,54 @@ function copyTemplateFile(repoRoot, relativeTemplatePath, force, dryRun) {
   return { status: destinationExists ? 'overwritten' : 'created', file: destinationRelativePath };
 }
 
+function normalizeTemplatePath(relativeTemplatePath) {
+  return String(relativeTemplatePath).replace(/\\/g, '/');
+}
+
+function usesPackageRootSource(repoRoot, relativeTemplatePath) {
+  return (
+    path.resolve(repoRoot) === PACKAGE_ROOT &&
+    PACKAGE_ROOT_SOURCE_OVERRIDES.has(normalizeTemplatePath(relativeTemplatePath))
+  );
+}
+
+function resolveTemplateSourcePath(repoRoot, relativeTemplatePath) {
+  if (usesPackageRootSource(repoRoot, relativeTemplatePath)) {
+    return path.join(PACKAGE_ROOT, relativeTemplatePath);
+  }
+  return path.join(TEMPLATE_ROOT, relativeTemplatePath);
+}
+
+function copyTemplateFile(repoRoot, relativeTemplatePath, force, dryRun) {
+  const sourcePath = resolveTemplateSourcePath(repoRoot, relativeTemplatePath);
+  const destinationRelativePath = toDestinationPath(relativeTemplatePath);
+  const destinationPath = path.join(repoRoot, destinationRelativePath);
+  return copyManagedSourceFile(
+    repoRoot,
+    sourcePath,
+    destinationPath,
+    destinationRelativePath,
+    force,
+    dryRun,
+  );
+}
+
 function ensureTemplateFilePresent(repoRoot, relativeTemplatePath, dryRun) {
-  const sourcePath = path.join(TEMPLATE_ROOT, relativeTemplatePath);
+  const sourcePath = resolveTemplateSourcePath(repoRoot, relativeTemplatePath);
   const destinationRelativePath = toDestinationPath(relativeTemplatePath);
   const destinationPath = path.join(repoRoot, destinationRelativePath);
-  const sourceContent = fs.readFileSync(sourcePath, 'utf8');
+  const sourceContent = fs.readFileSync(sourcePath);
 
   if (fs.existsSync(destinationPath)) {
-    const existingContent = fs.readFileSync(destinationPath, 'utf8');
-    if (existingContent === sourceContent) {
+    const existingContent = fs.readFileSync(destinationPath);
+    if (existingContent.equals(sourceContent)) {
       ensureExecutable(destinationPath, destinationRelativePath, dryRun);
       return { status: 'unchanged', file: destinationRelativePath };
     }
 
     if (isCriticalGuardrailPath(destinationRelativePath)) {
       if (!dryRun) {
-        fs.writeFileSync(destinationPath, sourceContent, 'utf8');
+        fs.writeFileSync(destinationPath, sourceContent);
         ensureExecutable(destinationPath, destinationRelativePath, dryRun);
       }
       return { status: dryRun ? 'would-repair-critical' : 'repaired-critical', file: destinationRelativePath };
@@ -230,13 +261,38 @@ function ensureTemplateFilePresent(repoRoot, relativeTemplatePath, dryRun) {
 
   ensureParentDir(repoRoot, destinationPath, dryRun);
   if (!dryRun) {
-    fs.writeFileSync(destinationPath, sourceContent, 'utf8');
+    fs.writeFileSync(destinationPath, sourceContent);
     ensureExecutable(destinationPath, destinationRelativePath, dryRun);
   }
 
   return { status: 'created', file: destinationRelativePath };
 }
 
+function materializePackageRepoTemplateFiles(repoRoot, relativeTemplatePaths, dryRun) {
+  if (path.resolve(repoRoot) !== PACKAGE_ROOT) {
+    return [];
+  }
+
+  const operations = [];
+  for (const relativeTemplatePath of relativeTemplatePaths) {
+    if (!PACKAGE_ROOT_SOURCE_OVERRIDES.has(normalizeTemplatePath(relativeTemplatePath))) {
+      continue;
+    }
+    const templateRelativePath = path.posix.join('templates', normalizeTemplatePath(relativeTemplatePath));
+    operations.push(
+      copyManagedSourceFile(
+        PACKAGE_ROOT,
+        path.join(PACKAGE_ROOT, relativeTemplatePath),
+        path.join(PACKAGE_ROOT, templateRelativePath),
+        templateRelativePath,
+        true,
+        dryRun,
+      ),
+    );
+  }
+  return operations;
+}
+
 function lockFilePath(repoRoot) {
   return path.join(repoRoot, LOCK_FILE_RELATIVE);
 }
@@ -521,121 +577,13 @@ function ensureManagedGitignore(repoRoot, dryRun) {
   return { status: 'updated', file: '.gitignore', note: 'appended gitguardex-managed entries' };
 }
 
-function stripJsonComments(source) {
-  let result = '';
-  let inString = false;
-  let escapeNext = false;
-  let inLineComment = false;
-  let inBlockComment = false;
-
-  for (let index = 0; index < source.length; index += 1) {
-    const current = source[index];
-    const next = source[index + 1];
-
-    if (inLineComment) {
-      if (current === '\n' || current === '\r') {
-        inLineComment = false;
-        result += current;
-      }
-      continue;
-    }
-
-    if (inBlockComment) {
-      if (current === '*' && next === '/') {
-        inBlockComment = false;
-        index += 1;
-        continue;
-      }
-      if (current === '\n' || current === '\r') {
-        result += current;
-      }
-      continue;
-    }
-
-    if (inString) {
-      result += current;
-      if (escapeNext) {
-        escapeNext = false;
-      } else if (current === '\\') {
-        escapeNext = true;
-      } else if (current === '"') {
-        inString = false;
-      }
-      continue;
-    }
-
-    if (current === '"') {
-      inString = true;
-      result += current;
-      continue;
-    }
-
-    if (current === '/' && next === '/') {
-      inLineComment = true;
-      index += 1;
-      continue;
-    }
-
-    if (current === '/' && next === '*') {
-      inBlockComment = true;
-      index += 1;
-      continue;
-    }
-
-    result += current;
-  }
-
-  return result;
-}
-
-function stripJsonTrailingCommas(source) {
-  let result = '';
-  let inString = false;
-  let escapeNext = false;
-
-  for (let index = 0; index < source.length; index += 1) {
-    const current = source[index];
-
-    if (inString) {
-      result += current;
-      if (escapeNext) {
-        escapeNext = false;
-      } else if (current === '\\') {
-        escapeNext = true;
-      } else if (current === '"') {
-        inString = false;
-      }
-      continue;
-    }
-
-    if (current === '"') {
-      inString = true;
-      result += current;
-      continue;
-    }
-
-    if (current === ',') {
-      let lookahead = index + 1;
-      while (lookahead < source.length && /\s/.test(source[lookahead])) {
-        lookahead += 1;
-      }
-      if (source[lookahead] === '}' || source[lookahead] === ']') {
-        continue;
-      }
-    }
-
-    result += current;
-  }
-
-  return result;
-}
-
 function parseJsonObjectLikeFile(source, relativePath) {
-  let parsed;
-  try {
-    parsed = JSON.parse(stripJsonTrailingCommas(stripJsonComments(source)));
-  } catch (error) {
-    throw new Error(`Unable to parse ${relativePath} as JSON or JSONC: ${error.message}`);
+  const errors = [];
+  const parsed = parseJsonc(source, errors, { allowTrailingComma: true });
+
+  if (errors.length > 0) {
+    const formattedErrors = errors.map((entry) => printParseErrorCode(entry.error)).join(', ');
+    throw new Error(`Unable to parse ${relativePath} as JSON or JSONC: ${formattedErrors}`);
   }
 
   if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
@@ -806,6 +754,7 @@ module.exports = {
   ensureHookShim,
   copyTemplateFile,
   ensureTemplateFilePresent,
+  materializePackageRepoTemplateFiles,
   ensureOmxScaffold,
   ensureLockRegistry,
   lockStateOrError,
@@ -815,8 +764,6 @@ module.exports = {
   removeLegacyManagedRepoFile,
   ensureAgentsSnippet,
   ensureManagedGitignore,
-  stripJsonComments,
-  stripJsonTrailingCommas,
   parseJsonObjectLikeFile,
   buildRepoVscodeSettings,
   ensureRepoVscodeSettings,

package/src/toolchain/index.js

@@ -17,50 +17,18 @@ const {
   envFlagIsTruthy,
 } = require('../context');
 const { run } = require('../core/runtime');
+const {
+  parseVersionString,
+  compareParsedVersions,
+  isNewerVersion,
+} = require('../core/versions');
+const { readSingleLineFromStdin } = require('../core/stdin');
 const { colorize } = require('../output');
 
 function isInteractiveTerminal() {
   return Boolean(process.stdin.isTTY && process.stdout.isTTY);
 }
 
-const stdinWaitArray = new Int32Array(new SharedArrayBuffer(4));
-
-function sleepSyncMs(milliseconds) {
-  Atomics.wait(stdinWaitArray, 0, 0, milliseconds);
-}
-
-function readSingleLineFromStdin() {
-  let input = '';
-  const buffer = Buffer.alloc(1);
-
-  while (true) {
-    let bytesRead = 0;
-    try {
-      bytesRead = fs.readSync(process.stdin.fd, buffer, 0, 1);
-    } catch (error) {
-      if (error && ['EAGAIN', 'EWOULDBLOCK', 'EINTR'].includes(error.code)) {
-        sleepSyncMs(15);
-        continue;
-      }
-      return input;
-    }
-
-    if (bytesRead === 0) {
-      if (process.stdin.isTTY) {
-        sleepSyncMs(15);
-        continue;
-      }
-      return input;
-    }
-
-    const char = buffer.toString('utf8', 0, bytesRead);
-    if (char === '\n' || char === '\r') {
-      return input;
-    }
-    input += char;
-  }
-}
-
 function parseAutoApproval(name) {
   const raw = process.env[name];
   if (raw == null) return null;
@@ -70,38 +38,6 @@ function parseAutoApproval(name) {
   return null;
 }
 
-function parseVersionString(version) {
-  const match = String(version || '').trim().match(/^v?(\d+)\.(\d+)\.(\d+)/);
-  if (!match) return null;
-  return [
-    Number.parseInt(match[1], 10),
-    Number.parseInt(match[2], 10),
-    Number.parseInt(match[3], 10),
-  ];
-}
-
-function compareParsedVersions(left, right) {
-  if (!left || !right) return 0;
-  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
-    const leftValue = left[index] || 0;
-    const rightValue = right[index] || 0;
-    if (leftValue > rightValue) return 1;
-    if (leftValue < rightValue) return -1;
-  }
-  return 0;
-}
-
-function isNewerVersion(latest, current) {
-  const latestParts = parseVersionString(latest);
-  const currentParts = parseVersionString(current);
-
-  if (!latestParts || !currentParts) {
-    return String(latest || '').trim() !== String(current || '').trim();
-  }
-
-  return compareParsedVersions(latestParts, currentParts) > 0;
-}
-
 function parseNpmVersionOutput(stdout) {
   const trimmed = String(stdout || '').trim();
   if (!trimmed) return '';