@autotests/playwright-impact 0.1.2 → 0.1.4

package/LICENSE

@@ -1,15 +1,21 @@
-ISC License
+MIT License
 
 Copyright (c) 2026 Alex Kiselev
 
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -23,25 +23,27 @@ Create `impact.js` in your repo root:
 ```js
 const { analyzeImpactedSpecs } = require('@autotests/playwright-impact');
 
-const result = analyzeImpactedSpecs({
-  repoRoot: process.cwd(),
-  profile: {
-    testsRootRelative: 'tests',
-    changedSpecPrefix: 'tests/',
-    isRelevantPomPath: (filePath) =>
-      (filePath.startsWith('src/pages/') || filePath.startsWith('src/utils/')) &&
-      (filePath.endsWith('.ts') || filePath.endsWith('.tsx')),
-  },
-});
-
-if (!result.hasAnythingToRun) {
-  console.log('No impacted specs found');
-  process.exit(0);
-}
-
-for (const spec of result.selectedSpecsRelative) {
-  console.log(spec);
-}
+(async () => {
+  const result = await analyzeImpactedSpecs({
+    repoRoot: process.cwd(),
+    profile: {
+      testsRootRelative: 'tests',
+      changedSpecPrefix: 'tests/',
+      isRelevantPomPath: (filePath) =>
+        (filePath.startsWith('src/pages/') || filePath.startsWith('src/utils/')) &&
+        (filePath.endsWith('.ts') || filePath.endsWith('.tsx')),
+    },
+  });
+
+  if (!result.hasAnythingToRun) {
+    console.log('No impacted specs found');
+    process.exit(0);
+  }
+
+  for (const spec of result.selectedSpecsRelative) {
+    console.log(spec);
+  }
+})();
 ```
 
 Save as `impact.js`
@@ -80,24 +82,26 @@ Use this when your branch is compared to `origin/main`.
 ```js
 const { analyzeImpactedSpecs } = require('@autotests/playwright-impact');
 
-const result = analyzeImpactedSpecs({
-  repoRoot: process.cwd(),
-  baseRef: 'origin/main',
-  profile: {
-    testsRootRelative: 'tests',
-    changedSpecPrefix: 'tests/',
-    isRelevantPomPath: (filePath) =>
-      (filePath.startsWith('src/pages/') || filePath.startsWith('src/utils/')) &&
-      (filePath.endsWith('.ts') || filePath.endsWith('.tsx')),
-  },
-});
-
-if (!result.hasAnythingToRun) {
-  console.log('No impacted specs found');
-  process.exit(0);
-}
-
-console.log(result.selectedSpecsRelative.join(' '));
+(async () => {
+  const result = await analyzeImpactedSpecs({
+    repoRoot: process.cwd(),
+    baseRef: 'origin/main',
+    profile: {
+      testsRootRelative: 'tests',
+      changedSpecPrefix: 'tests/',
+      isRelevantPomPath: (filePath) =>
+        (filePath.startsWith('src/pages/') || filePath.startsWith('src/utils/')) &&
+        (filePath.endsWith('.ts') || filePath.endsWith('.tsx')),
+    },
+  });
+
+  if (!result.hasAnythingToRun) {
+    console.log('No impacted specs found');
+    process.exit(0);
+  }
+
+  console.log(result.selectedSpecsRelative.join(' '));
+})();
 ```
 
 ## Typical CI Usage

package/package.json

@@ -1,16 +1,9 @@
 {
   "name": "@autotests/playwright-impact",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Core impacted-test selection library for changed POM/method analysis",
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/akiselevaristek/playwright-impact.git"
-  },
-  "homepage": "https://github.com/akiselevaristek/playwright-impact#readme",
-  "bugs": {
-    "url": "https://github.com/akiselevaristek/playwright-impact/issues"
-  },
+  "license": "MIT",
+  "repository": "github:akiselevaristek/playwright-impact",
   "main": "src/index.js",
   "exports": {
     ".": "./src/index.js"
@@ -18,7 +11,6 @@
   "types": "src/index.d.ts",
   "files": [
     "src",
-    "tests",
     "README.md",
     "LICENSE"
   ],
@@ -38,5 +30,8 @@
   "devDependencies": {
     "@types/node": "^24.10.9",
     "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "isomorphic-git": "^1.37.2"
   }
 }

package/src/analyze-impacted-specs.js

@@ -52,7 +52,7 @@ const normalizeFileExtensions = (fileExtensions) => {
  * 3) Stage A preselect specs by impacted fixture keys
  * 4) Stage B precise/uncertain method matching with selection bias policy
  */
-const analyzeImpactedSpecs = ({
+const analyzeImpactedSpecs = async ({
   repoRoot,
   baseRef = null,
   profile,
@@ -74,7 +74,7 @@ const analyzeImpactedSpecs = ({
     : getDefaultGlobalWatchPatterns();
 
   // Stage 0: gather changed files and keep only profile-relevant subsets.
-  const changedEntriesResult = getChangedEntries({
+  const changedEntriesResult = await getChangedEntries({
     repoRoot,
     baseRef,
     includeWorkingTreeWithBase,
@@ -104,7 +104,7 @@ const analyzeImpactedSpecs = ({
     .map((entry) => entry.effectivePath)
     .filter(Boolean);
   const untrackedSpecFiles = includeUntrackedSpecs
-    ? getUntrackedSpecPaths({ repoRoot, changedSpecPrefix: profile.changedSpecPrefix, fileExtensions: effectiveExtensions })
+    ? await getUntrackedSpecPaths({ repoRoot, changedSpecPrefix: profile.changedSpecPrefix, fileExtensions: effectiveExtensions })
     : [];
   const directChangedSpecFiles = Array.from(new Set([...changedSpecFiles, ...untrackedSpecFiles])).sort((a, b) => a.localeCompare(b));
 
@@ -200,10 +200,20 @@ const analyzeImpactedSpecs = ({
 
   // Stage 1: semantic seed and callgraph propagation from changed POM entries.
   if (changedPomEntries.length > 0) {
+    const contentsByEntry = new Map();
+    for (const entry of changedPomEntries) {
+      const key = `${entry.status}:${entry.oldPath || ''}:${entry.newPath || ''}:${entry.effectivePath || ''}`;
+      contentsByEntry.set(key, await readChangeContents({ repoRoot, entry, baseRef }));
+    }
+    const readContentsFromCache = (entry) => {
+      const key = `${entry.status}:${entry.oldPath || ''}:${entry.newPath || ''}:${entry.effectivePath || ''}`;
+      return contentsByEntry.get(key) || { basePath: null, headPath: null, baseContent: null, headContent: null };
+    };
+
     const changedMethodsResult = collectChangedMethodsByClass({
       changedPomEntries,
       baseRef,
-      readChangeContents: (entry, entryBaseRef) => readChangeContents({ repoRoot, entry, baseRef: entryBaseRef }),
+      readChangeContents: (entry) => readContentsFromCache(entry),
     });
 
     semanticStats = changedMethodsResult.stats;
@@ -214,7 +224,7 @@ const analyzeImpactedSpecs = ({
         changedPomEntries,
         childrenByParent,
         baseRef,
-        readChangeContents: (entry, entryBaseRef) => readChangeContents({ repoRoot, entry, baseRef: entryBaseRef }),
+        readChangeContents: (entry) => readContentsFromCache(entry),
       });
 
       const impactedMethodsResult = buildImpactedMethodsByClass({

package/src/index.d.ts

@@ -64,7 +64,7 @@ export type AnalyzeResult = {
   globalWatchResolvedFiles: string[];
 };
 
-export function analyzeImpactedSpecs(options: AnalyzeOptions): AnalyzeResult;
+export function analyzeImpactedSpecs(options: AnalyzeOptions): Promise<AnalyzeResult>;
 
 export function formatSelectionReasonsForLog(args: {
   selectedSpecs: string[];

package/src/modules/file-and-git-helpers.js

@@ -2,20 +2,11 @@
 
 const fs = require('fs');
 const path = require('path');
-const { runCommand } = require('./shell');
+const git = require('isomorphic-git');
 
 const STATUS_PRIORITY = { D: 4, R: 3, M: 2, A: 1 };
 const SUPPORTED_FILE_EXTENSIONS = new Set(['.ts', '.tsx']);
 
-const readFileFromBaseRef = ({ repoRoot, relativePath, baseRef }) => {
-  if (!relativePath) return null;
-  const effectiveBaseRef = String(baseRef || 'HEAD').trim();
-  if (!effectiveBaseRef) return null;
-  const showResult = runCommand('git', ['show', `${effectiveBaseRef}:${relativePath}`], { cwd: repoRoot });
-  if (showResult.status !== 0 || showResult.error) return null;
-  return typeof showResult.stdout === 'string' ? showResult.stdout : null;
-};
-
 const readFileFromWorkingTree = ({ repoRoot, relativePath }) => {
   if (!relativePath) return null;
   const absolutePath = path.join(repoRoot, relativePath);
@@ -74,27 +65,7 @@ const listFilesRecursive = (rootDir) => {
   return files;
 };
 
-const runDiffAndParse = ({ repoRoot, args }) => {
-  // Use rename detection to keep semantic compare stable across pure file moves/renames.
-  const result = runCommand('git', ['diff', '--name-status', '-M', ...args], { cwd: repoRoot });
-  if (result.error) throw new Error(`Failed to execute git diff: ${result.error.message}`);
-  if (result.status !== 0) {
-    const details = (result.stderr || result.stdout || '').trim();
-    throw new Error(`git diff failed with code ${result.status}: ${details}`);
-  }
-
-  return result.stdout
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean)
-    .map(parseChangedEntryLine)
-    .filter((entry) => Boolean(entry));
-};
-
 const normalizeEntryStatus = (entry, warnings) => {
-  // Compatibility fallback:
-  // - C behaves like an add because there is no stable base path identity
-  // - T/U/unknown behave like modify to preserve fail-open behavior
   const status = String(entry.status || '').toUpperCase();
   if (['A', 'M', 'D', 'R'].includes(status)) return { ...entry, status };
 
@@ -119,7 +90,6 @@ const mergeByPriority = (existing, incoming) => {
   if (incomingPriority > currentPriority) return incoming;
   if (incomingPriority < currentPriority) return existing;
 
-  // If priorities are equal, keep entry with richer rename info.
   if (incoming.status === 'R' && incoming.oldPath && incoming.newPath) return incoming;
   return existing;
 };
@@ -129,25 +99,257 @@ const isValidExtension = (filePath, fileExtensions) => {
   return fileExtensions.includes(ext);
 };
 
-const getUntrackedPaths = ({ repoRoot }) => {
-  const result = runCommand('git', ['ls-files', '--others', '--exclude-standard'], { cwd: repoRoot });
-  if (result.error || result.status !== 0) return [];
+const resolveRefBase = async ({ repoRoot, refBase }) => {
+  if (/^[0-9a-f]{40}$/i.test(refBase)) return refBase;
+
+  const candidates = [
+    refBase,
+    `refs/heads/${refBase}`,
+    `refs/remotes/${refBase}`,
+    `refs/tags/${refBase}`,
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      return await git.resolveRef({ fs, dir: repoRoot, ref: candidate });
+    } catch (_) {
+      // Try next candidate.
+    }
+  }
+
+  throw new Error(`Unknown git ref: ${refBase}`);
+};
+
+const resolveRevisionToOid = async ({ repoRoot, ref }) => {
+  const source = String(ref || 'HEAD').trim();
+  if (!source) throw new Error('Missing git ref');
+
+  const match = source.match(/^(.*)~(\d+)$/);
+  const baseRef = match ? (match[1] || 'HEAD') : source;
+  const backSteps = match ? Number.parseInt(match[2], 10) : 0;
+
+  let oid = await resolveRefBase({ repoRoot, refBase: baseRef });
+  for (let index = 0; index < backSteps; index += 1) {
+    const commit = await git.readCommit({ fs, dir: repoRoot, oid });
+    const parent = commit?.commit?.parent?.[0];
+    if (!parent) throw new Error(`Cannot resolve ${source}: parent commit is missing`);
+    oid = parent;
+  }
+
+  return oid;
+};
+
+const readFileFromBaseRef = async ({ repoRoot, relativePath, baseRef }) => {
+  if (!relativePath) return null;
+  try {
+    const refOid = await resolveRevisionToOid({ repoRoot, ref: baseRef || 'HEAD' });
+    const blob = await git.readBlob({ fs, dir: repoRoot, oid: refOid, filepath: relativePath });
+    return Buffer.from(blob.blob).toString('utf8');
+  } catch (_) {
+    return null;
+  }
+};
+
+const getTrackedFileOidAtRef = async ({ repoRoot, refOid, filepath }) => {
+  try {
+    const blob = await git.readBlob({ fs, dir: repoRoot, oid: refOid, filepath });
+    return blob.oid;
+  } catch (_) {
+    return null;
+  }
+};
+
+const getWorkingFileOid = async ({ repoRoot, filepath }) => {
+  const absolutePath = path.join(repoRoot, filepath);
+  if (!fs.existsSync(absolutePath)) return null;
+  const bytes = fs.readFileSync(absolutePath);
+  const hashed = await git.hashBlob({ object: bytes });
+  return hashed.oid;
+};
+
+const applyRenameDetection = ({ entries, warnings }) => {
+  const adds = entries
+    .filter((entry) => entry.status === 'A' && entry.newOid)
+    .map((entry) => ({ ...entry, consumed: false }));
+  const deletions = entries.filter((entry) => entry.status === 'D' && entry.oldOid);
+  const survivors = entries.filter((entry) => entry.status !== 'A' && entry.status !== 'D');
+
+  for (const del of deletions) {
+    const match = adds.find((add) => !add.consumed && add.newOid === del.oldOid);
+    if (!match) {
+      survivors.push(del);
+      continue;
+    }
+
+    match.consumed = true;
+    survivors.push({
+      status: 'R',
+      oldPath: del.oldPath,
+      newPath: match.newPath,
+      effectivePath: match.newPath,
+      rawStatus: 'R100',
+    });
+  }
+
+  for (const add of adds) {
+    if (add.consumed) continue;
+    survivors.push(add);
+  }
+
+  // Ensure deterministic order.
+  return survivors
+    .map((entry) => {
+      const { oldOid, newOid, ...rest } = entry;
+      return rest;
+    })
+    .sort((a, b) => a.effectivePath.localeCompare(b.effectivePath));
+};
+
+const getDiffEntriesBetweenRefs = async ({ repoRoot, fromRef, toRef = 'HEAD' }) => {
+  const fromOid = await resolveRevisionToOid({ repoRoot, ref: fromRef });
+  const toOid = await resolveRevisionToOid({ repoRoot, ref: toRef });
+  const rawEntries = [];
+  const fromFiles = await git.listFiles({ fs, dir: repoRoot, ref: fromOid });
+  const toFiles = await git.listFiles({ fs, dir: repoRoot, ref: toOid });
+
+  const fromMap = new Map();
+  for (const filepath of fromFiles) {
+    const blob = await git.readBlob({ fs, dir: repoRoot, oid: fromOid, filepath });
+    fromMap.set(filepath, blob.oid);
+  }
+
+  const toMap = new Map();
+  for (const filepath of toFiles) {
+    const blob = await git.readBlob({ fs, dir: repoRoot, oid: toOid, filepath });
+    toMap.set(filepath, blob.oid);
+  }
+
+  const allPaths = new Set([...fromMap.keys(), ...toMap.keys()]);
+  for (const filepath of allPaths) {
+    const fromOidEntry = fromMap.get(filepath) || null;
+    const toOidEntry = toMap.get(filepath) || null;
+
+    if (fromOidEntry && !toOidEntry) {
+      rawEntries.push({
+        status: 'D',
+        oldPath: filepath,
+        newPath: null,
+        effectivePath: filepath,
+        rawStatus: 'D',
+        oldOid: fromOidEntry,
+        newOid: null,
+      });
+      continue;
+    }
+
+    if (!fromOidEntry && toOidEntry) {
+      rawEntries.push({
+        status: 'A',
+        oldPath: null,
+        newPath: filepath,
+        effectivePath: filepath,
+        rawStatus: 'A',
+        oldOid: null,
+        newOid: toOidEntry,
+      });
+      continue;
+    }
+
+    if (fromOidEntry !== toOidEntry) {
+      rawEntries.push({
+        status: 'M',
+        oldPath: filepath,
+        newPath: filepath,
+        effectivePath: filepath,
+        rawStatus: 'M',
+        oldOid: fromOidEntry,
+        newOid: toOidEntry,
+      });
+    }
+  }
 
-  return result.stdout
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean)
+  return applyRenameDetection({ entries: rawEntries, warnings: [] });
+};
+
+const getWorkingTreeDiffEntries = async ({ repoRoot }) => {
+  const headOid = await resolveRevisionToOid({ repoRoot, ref: 'HEAD' });
+  const rawEntries = [];
+  const headFiles = await git.listFiles({ fs, dir: repoRoot, ref: headOid });
+  const indexFiles = await git.listFiles({ fs, dir: repoRoot });
+  const indexSet = new Set(indexFiles);
+
+  const headMap = new Map();
+  for (const filepath of headFiles) {
+    headMap.set(filepath, await getTrackedFileOidAtRef({ repoRoot, refOid: headOid, filepath }));
+  }
+
+  const candidates = new Set([...headFiles, ...indexFiles]);
+  for (const filepath of candidates) {
+    const headFileOid = headMap.get(filepath) || null;
+    const workFileOid = await getWorkingFileOid({ repoRoot, filepath });
+    const inHead = Boolean(headFileOid);
+    const inIndex = indexSet.has(filepath);
+
+    if (!inHead && inIndex && workFileOid) {
+      rawEntries.push({
+        status: 'A',
+        oldPath: null,
+        newPath: filepath,
+        effectivePath: filepath,
+        rawStatus: 'A',
+        oldOid: null,
+        newOid: workFileOid,
+      });
+      continue;
+    }
+
+    if (inHead && !workFileOid) {
+      rawEntries.push({
+        status: 'D',
+        oldPath: filepath,
+        newPath: null,
+        effectivePath: filepath,
+        rawStatus: 'D',
+        oldOid: headFileOid,
+        newOid: null,
+      });
+      continue;
+    }
+
+    if (inHead && workFileOid && headFileOid !== workFileOid) {
+      rawEntries.push({
+        status: 'M',
+        oldPath: filepath,
+        newPath: filepath,
+        effectivePath: filepath,
+        rawStatus: 'M',
+        oldOid: headFileOid,
+        newOid: workFileOid,
+      });
+    }
+  }
+
+  return applyRenameDetection({ entries: rawEntries, warnings: [] });
+};
+
+const getUntrackedPaths = async ({ repoRoot }) => {
+  const matrix = await git.statusMatrix({ fs, dir: repoRoot });
+  return matrix
+    .filter(([, head, workdir, stage]) => head === 0 && workdir === 2 && stage === 0)
+    .map(([filepath]) => filepath)
     .sort((a, b) => a.localeCompare(b));
 };
 
-const getUntrackedSpecPaths = ({ repoRoot, changedSpecPrefix, fileExtensions = ['.ts', '.tsx'] }) => {
-  return getUntrackedPaths({ repoRoot })
+const getUntrackedSpecPaths = async ({ repoRoot, changedSpecPrefix, fileExtensions = ['.ts', '.tsx'] }) => {
+  const untracked = await getUntrackedPaths({ repoRoot });
+  return untracked
     .filter((filePath) => filePath.startsWith(changedSpecPrefix))
     .filter((filePath) => fileExtensions.some((ext) => filePath.endsWith(`.spec${ext}`)));
 };
 
-const getUntrackedSourceEntries = ({ repoRoot, profile, fileExtensions = ['.ts', '.tsx'] }) => {
-  return getUntrackedPaths({ repoRoot })
+const getUntrackedSourceEntries = async ({ repoRoot, profile, fileExtensions = ['.ts', '.tsx'] }) => {
+  const untracked = await getUntrackedPaths({ repoRoot });
+  return untracked
     .filter((filePath) => isValidExtension(filePath, fileExtensions))
     .filter((filePath) => profile.isRelevantPomPath(filePath))
     .map((filePath) => ({
@@ -159,31 +361,24 @@ const getUntrackedSourceEntries = ({ repoRoot, profile, fileExtensions = ['.ts',
     }));
 };
 
-/**
- * Build normalized changed entries for analysis.
- * Sources:
- * - git diff <base>...HEAD (if baseRef is set)
- * - git diff HEAD (working tree, optionally merged with base mode)
- * - untracked source files matching profile.isRelevantPomPath
- */
-const getChangedEntries = ({ repoRoot, baseRef, includeWorkingTreeWithBase = true, profile = null, fileExtensions = ['.ts', '.tsx'] }) => {
+const getChangedEntries = async ({ repoRoot, baseRef, includeWorkingTreeWithBase = true, profile = null, fileExtensions = ['.ts', '.tsx'] }) => {
   const warnings = [];
   let statusFallbackHits = 0;
 
-  const baseHeadEntries = baseRef ? runDiffAndParse({ repoRoot, args: [`${baseRef}...HEAD`] }) : [];
-  const workingTreeEntries = (!baseRef || includeWorkingTreeWithBase) ? runDiffAndParse({ repoRoot, args: ['HEAD'] }) : [];
+  const baseHeadEntries = baseRef
+    ? await getDiffEntriesBetweenRefs({ repoRoot, fromRef: baseRef, toRef: 'HEAD' })
+    : [];
+  const workingTreeEntries = (!baseRef || includeWorkingTreeWithBase)
+    ? await getWorkingTreeDiffEntries({ repoRoot })
+    : [];
   const combined = [...baseHeadEntries, ...workingTreeEntries];
 
-  if (!baseRef && combined.length === 0) {
-    // Keep backward-compatible behavior for local-only mode where `HEAD` diff is the primary source.
-    combined.push(...workingTreeEntries);
-  }
-
+  let untrackedSourceEntries = [];
   if (profile && typeof profile.isRelevantPomPath === 'function') {
-    combined.push(...getUntrackedSourceEntries({ repoRoot, profile, fileExtensions }));
+    untrackedSourceEntries = await getUntrackedSourceEntries({ repoRoot, profile, fileExtensions });
+    combined.push(...untrackedSourceEntries);
   }
 
-  // Deterministic status merge by effective path with explicit precedence (D > R > M > A).
   const mergedByPath = new Map();
   for (const entry of combined) {
     const normalized = normalizeEntryStatus(entry, warnings);
@@ -204,16 +399,16 @@ const getChangedEntries = ({ repoRoot, baseRef, includeWorkingTreeWithBase = tru
     changedEntriesBySource: {
       fromBaseHead: baseHeadEntries.length,
       fromWorkingTree: workingTreeEntries.length,
-      fromUntracked: profile ? getUntrackedSourceEntries({ repoRoot, profile, fileExtensions }).length : 0,
+      fromUntracked: untrackedSourceEntries.length,
     },
   };
 };
 
-const readChangeContents = ({ repoRoot, entry, baseRef }) => {
+const readChangeContents = async ({ repoRoot, entry, baseRef }) => {
   const basePath = entry?.status === 'R' ? entry.oldPath : entry?.oldPath;
   const headPath = entry?.status === 'R' ? entry.newPath : entry?.newPath;
 
-  const baseContent = basePath ? readFileFromBaseRef({ repoRoot, relativePath: basePath, baseRef }) : null;
+  const baseContent = basePath ? await readFileFromBaseRef({ repoRoot, relativePath: basePath, baseRef }) : null;
   const headContent = headPath ? readFileFromWorkingTree({ repoRoot, relativePath: headPath }) : null;
 
   return { basePath: basePath || null, headPath: headPath || null, baseContent, headContent };
@@ -230,5 +425,6 @@ module.exports = {
     parseChangedEntryLine,
     normalizeEntryStatus,
     mergeByPriority,
+    resolveRevisionToOid,
   },
 };

package/src/modules/shell.js

@@ -1,24 +0,0 @@
-'use strict';
-
-const { spawnSync } = require('child_process');
-
-/**
- * Small spawnSync wrapper with normalized process result shape.
- */
-const runCommand = (command, args, options = {}) => {
-  const result = spawnSync(command, args, {
-    encoding: 'utf-8',
-    ...options,
-  });
-
-  return {
-    status: result.status ?? 1,
-    stdout: result.stdout || '',
-    stderr: result.stderr || '',
-    error: result.error || null,
-  };
-};
-
-module.exports = {
-  runCommand,
-};