@lumy-pack/line-lore 0.0.4 → 0.0.6

package/dist/index.cjs

@@ -317,6 +317,51 @@ async function gitExec(args, options) {
     LineLoreErrorCode.GIT_COMMAND_FAILED
   );
 }
+async function gitPipe(producerArgs, consumerArgs, options) {
+  const { cwd, timeout } = options ?? {};
+  const pipeArgs = [...producerArgs, "|", ...consumerArgs];
+  try {
+    const result = await (0, import_execa.execa)("git", producerArgs, {
+      cwd,
+      timeout,
+      reject: false
+    }).pipe("git", consumerArgs, { cwd, timeout, reject: false });
+    const exitCode = result.exitCode ?? 0;
+    if (exitCode !== 0) {
+      throw new LineLoreError(
+        LineLoreErrorCode.GIT_COMMAND_FAILED,
+        `git pipe failed with exit code ${exitCode}: ${result.stderr}`,
+        {
+          command: "git",
+          args: pipeArgs,
+          exitCode,
+          stderr: result.stderr,
+          cwd
+        }
+      );
+    }
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode
+    };
+  } catch (error) {
+    if (error instanceof LineLoreError) throw error;
+    const isTimeout = error instanceof Error && "isTerminated" in error && error.timedOut === true;
+    if (isTimeout) {
+      throw new LineLoreError(
+        LineLoreErrorCode.GIT_TIMEOUT,
+        `git pipe timed out after ${timeout}ms`,
+        { command: "git", args: pipeArgs, timeout, cwd }
+      );
+    }
+    throw new LineLoreError(
+      LineLoreErrorCode.GIT_COMMAND_FAILED,
+      `git pipe failed: ${error instanceof Error ? error.message : String(error)}`,
+      { command: "git", args: pipeArgs, cwd }
+    );
+  }
+}
 async function shellExec(command, args, options) {
   return execCommand(
     command,
@@ -338,14 +383,22 @@ var init_executor = __esm({
 // src/core/ancestry/ancestry.ts
 async function findMergeCommit(commitSha, options) {
   const ref = options?.ref ?? "HEAD";
+  const budget = options?.timeout ?? DEFAULT_ANCESTRY_TIMEOUT;
+  const startTime = Date.now();
   const firstParentResult = await findMergeCommitWithArgs(
     commitSha,
     ref,
     ["--first-parent"],
-    options
+    { ...options, timeout: budget }
   );
   if (firstParentResult) return firstParentResult;
-  return findMergeCommitWithArgs(commitSha, ref, [], options);
+  const elapsed = Date.now() - startTime;
+  const remaining = budget - elapsed;
+  if (remaining <= 0) return null;
+  return findMergeCommitWithArgs(commitSha, ref, [], {
+    ...options,
+    timeout: remaining
+  });
 }
 async function findMergeCommitWithArgs(commitSha, ref, extraArgs, options) {
   try {
@@ -393,15 +446,18 @@ function extractPRFromMergeMessage(subject) {
   if (squashMatch) return parseInt(squashMatch[1], 10);
   const glMatch = /!(\d+)\s*$/.exec(subject);
   if (glMatch) return parseInt(glMatch[1], 10);
+  const adoMatch = /Merged PR (\d+):/.exec(subject);
+  if (adoMatch) return parseInt(adoMatch[1], 10);
   return null;
 }
-var import_common_utils9;
+var import_common_utils9, DEFAULT_ANCESTRY_TIMEOUT;
 var init_ancestry = __esm({
   "src/core/ancestry/ancestry.ts"() {
     "use strict";
     init_cjs_shims();
     import_common_utils9 = require("@winglet/common-utils");
     init_executor();
+    DEFAULT_ANCESTRY_TIMEOUT = 3e4;
   }
 });
 
@@ -437,14 +493,10 @@ async function computePatchId(commitSha, options) {
   const cached = await cache.get(commitSha);
   if (cached) return cached;
   try {
-    const cwd = options?.cwd ?? ".";
-    const result = await shellExec(
-      "bash",
-      [
-        "-c",
-        `git -C "${cwd}" diff "${commitSha}^..${commitSha}" | git patch-id --stable`
-      ],
-      { timeout: options?.timeout }
+    const result = await gitPipe(
+      ["diff", `${commitSha}^..${commitSha}`],
+      ["patch-id", "--stable"],
+      { cwd: options?.cwd, timeout: options?.timeout }
     );
     const patchId = result.stdout.trim().split(/\s+/)[0];
     if (!patchId) return null;
@@ -460,15 +512,18 @@ async function findPatchIdMatch(commitSha, options) {
   const targetPatchId = await computePatchId(commitSha, options);
   if (!targetPatchId) return null;
   try {
-    const logResult = await gitExec(
-      ["log", "--format=%H", `-${scanDepth}`, ref],
-      { cwd: options?.cwd, timeout: options?.timeout }
+    const result = await gitPipe(
+      ["log", `-${scanDepth}`, "-p", ref],
+      ["patch-id", "--stable"],
+      { cwd: options?.cwd, timeout: options?.timeout ?? 6e4 }
     );
-    const candidates = (0, import_common_utils10.filter)(logResult.stdout.trim().split("\n"), import_common_utils10.isTruthy);
-    for (const candidateSha of candidates) {
-      if (candidateSha === commitSha) continue;
-      const candidatePatchId = await computePatchId(candidateSha, options);
-      if (candidatePatchId && candidatePatchId === targetPatchId) {
+    const lines = (0, import_common_utils10.filter)(result.stdout.trim().split("\n"), import_common_utils10.isTruthy);
+    const cache = getCache(options?.repoId, options?.noCache);
+    for (const line of lines) {
+      const [patchId, candidateSha] = line.split(/\s+/);
+      if (!patchId || !candidateSha) continue;
+      await cache.set(candidateSha, patchId);
+      if (candidateSha !== commitSha && patchId === targetPatchId) {
         return { matchedSha: candidateSha, patchId: targetPatchId };
       }
     }
@@ -525,10 +580,40 @@ function getCache2(repoId, noCache) {
   }
   return cache;
 }
-async function lookupPR(commitSha, adapter, options) {
-  const cache = getCache2(options?.repoId, options?.noCache);
+function toCachedPR(pr) {
+  return {
+    number: pr.number,
+    title: pr.title,
+    author: pr.author,
+    url: pr.url,
+    mergeCommit: pr.mergeCommit,
+    baseBranch: pr.baseBranch,
+    mergedAt: pr.mergedAt ? new Date(pr.mergedAt).getTime() : void 0
+  };
+}
+function fromCachedPR(cached) {
+  let mergedAt;
+  if (cached.mergedAt != null) {
+    mergedAt = typeof cached.mergedAt === "number" ? new Date(cached.mergedAt).toISOString() : String(cached.mergedAt);
+  }
+  return {
+    number: cached.number,
+    title: cached.title,
+    author: cached.author,
+    url: cached.url,
+    mergeCommit: cached.mergeCommit,
+    baseBranch: cached.baseBranch,
+    mergedAt
+  };
+}
+async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
+  const cache = getCache2(
+    options?.repoId,
+    options?.cacheOnly ? false : options?.noCache
+  );
   const cached = await cache.get(commitSha);
-  if (cached) return cached;
+  if (cached) return fromCachedPR(cached);
+  if (options?.cacheOnly) return null;
   let mergeBasedPR = null;
   const mergeResult = await findMergeCommit(commitSha, options);
   if (mergeResult) {
@@ -551,39 +636,46 @@ async function lookupPR(commitSha, adapter, options) {
         };
       }
       if (!options?.deep || mergeBasedPR.mergedAt) {
-        await cache.set(commitSha, mergeBasedPR);
+        await cache.set(commitSha, toCachedPR(mergeBasedPR));
         return mergeBasedPR;
       }
     }
   }
-  const patchIdMatch = await findPatchIdMatch(commitSha, {
-    ...options,
-    scanDepth: options?.deep ? DEEP_SCAN_DEPTH : void 0
-  });
-  if (patchIdMatch) {
-    const result = await lookupPR(patchIdMatch.matchedSha, adapter, options);
-    if (result) {
-      await cache.set(commitSha, result);
-      return result;
-    }
-  }
   if (mergeBasedPR) {
-    await cache.set(commitSha, mergeBasedPR);
+    await cache.set(commitSha, toCachedPR(mergeBasedPR));
     return mergeBasedPR;
   }
   if (adapter) {
     const prInfo = await adapter.getPRForCommit(commitSha);
     if (prInfo?.mergedAt) {
-      await cache.set(commitSha, prInfo);
+      await cache.set(commitSha, toCachedPR(prInfo));
       return prInfo;
     }
   }
+  if (!options?.skipPatchIdScan && _recursionDepth < MAX_RECURSION_DEPTH) {
+    const patchIdMatch = await findPatchIdMatch(commitSha, {
+      ...options,
+      scanDepth: options?.deep ? DEEP_SCAN_DEPTH : void 0
+    });
+    if (patchIdMatch) {
+      const result = await lookupPR(
+        patchIdMatch.matchedSha,
+        adapter,
+        options,
+        _recursionDepth + 1
+      );
+      if (result) {
+        await cache.set(commitSha, toCachedPR(result));
+        return result;
+      }
+    }
+  }
   return null;
 }
 function resetPRCache() {
   cacheRegistry2.clear();
 }
-var cacheRegistry2, DEEP_SCAN_DEPTH;
+var cacheRegistry2, DEEP_SCAN_DEPTH, MAX_RECURSION_DEPTH;
 var init_pr_lookup = __esm({
   "src/core/pr-lookup/pr-lookup.ts"() {
     "use strict";
@@ -593,6 +685,7 @@ var init_pr_lookup = __esm({
     init_patch_id2();
     cacheRegistry2 = /* @__PURE__ */ new Map();
     DEEP_SCAN_DEPTH = 2e3;
+    MAX_RECURSION_DEPTH = 2;
   }
 });
 
@@ -861,6 +954,27 @@ function isVersionAtLeast(version, minVersion) {
   }
   return true;
 }
+async function checkCloneStatus(options) {
+  let partialClone = false;
+  let shallow = false;
+  try {
+    const shallowResult = await gitExec(
+      ["rev-parse", "--is-shallow-repository"],
+      { cwd: options?.cwd }
+    );
+    shallow = shallowResult.stdout.trim() === "true";
+  } catch {
+  }
+  try {
+    const partialResult = await gitExec(
+      ["config", "--get", "extensions.partialclone"],
+      { cwd: options?.cwd }
+    );
+    partialClone = partialResult.stdout.trim().length > 0;
+  } catch {
+  }
+  return { partialClone, shallow };
+}
 async function checkGitHealth(options) {
   const hints = [];
   let gitVersion = "0.0.0";
@@ -887,7 +1001,18 @@ async function checkGitHealth(options) {
       `Upgrade git to ${BLOOM_FILTER_MIN_VERSION.join(".")}+ for bloom filter support (current: ${gitVersion}).`
     );
   }
-  return { commitGraph, bloomFilter, gitVersion, hints };
+  const cloneStatus = await checkCloneStatus({ cwd: options?.cwd });
+  if (cloneStatus.partialClone) {
+    hints.push(
+      "Partial clone detected. Patch-ID scan (Strategy 4) will be skipped to avoid blob downloads."
+    );
+  }
+  if (cloneStatus.shallow) {
+    hints.push(
+      "Shallow repository detected. Ancestry-path results may be incomplete."
+    );
+  }
+  return { commitGraph, bloomFilter, gitVersion, hints, ...cloneStatus };
 }
 
 // src/platform/index.ts
@@ -2111,7 +2236,7 @@ async function runBlameAndAuth(adapter, options, execOptions) {
   }
   return { analyzed: blameResult.value, operatingLevel, warnings };
 }
-async function processEntry(entry, featureFlags, adapter, options, execOptions, repoId) {
+async function processEntry(entry, featureFlags, adapter, options, execOptions, repoId, skipPatchIdScan) {
   const nodes = [];
   const commitNode = {
     type: entry.isCosmetic ? "cosmetic_commit" : "original_commit",
@@ -2142,8 +2267,10 @@ async function processEntry(entry, featureFlags, adapter, options, execOptions,
     const prInfo = await lookupPR(targetSha, adapter, {
       ...execOptions,
       noCache: options.noCache,
+      cacheOnly: options.cacheOnly,
       deep: featureFlags.deepTrace,
-      repoId
+      repoId,
+      skipPatchIdScan
     });
     if (prInfo) {
       nodes.push({
@@ -2160,11 +2287,19 @@ async function processEntry(entry, featureFlags, adapter, options, execOptions,
   }
   return nodes;
 }
-async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOptions, repoId) {
+async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOptions, repoId, skipPatchIdScan) {
   const results = await Promise.allSettled(
     (0, import_common_utils11.map)(
       analyzed,
-      (entry) => processEntry(entry, featureFlags, adapter, options, execOptions, repoId)
+      (entry) => processEntry(
+        entry,
+        featureFlags,
+        adapter,
+        options,
+        execOptions,
+        repoId,
+        skipPatchIdScan
+      )
     )
   );
   return results.flatMap((r) => r.status === "fulfilled" ? r.value : []);
@@ -2195,14 +2330,36 @@ async function trace(options) {
   );
   const operatingLevel = blameAuth.operatingLevel || platform.operatingLevel;
   const warnings = [...platform.warnings, ...blameAuth.warnings];
+  if (options.cacheOnly && options.noCache) {
+    warnings.push(
+      "Both cacheOnly and noCache are set. cacheOnly takes precedence \u2014 cache reads are enabled."
+    );
+  }
   const featureFlags = computeFeatureFlags(operatingLevel, options);
+  let cloneStatus = { partialClone: false, shallow: false };
+  try {
+    const result = await checkCloneStatus({ cwd: options.cwd });
+    if (result) cloneStatus = result;
+  } catch {
+  }
+  if (cloneStatus.partialClone) {
+    warnings.push(
+      "Partial clone detected. Patch-ID scan (Strategy 4) will be skipped to avoid blob downloads."
+    );
+  }
+  if (cloneStatus.shallow) {
+    warnings.push(
+      "Shallow repository detected. Ancestry-path results may be incomplete."
+    );
+  }
   const nodes = await buildTraceNodes(
     blameAuth.analyzed,
     featureFlags,
     platform.adapter,
     options,
     execOptions,
-    repoId
+    repoId,
+    cloneStatus.partialClone || void 0
   );
   return { nodes, operatingLevel, featureFlags, warnings };
 }