@lumy-pack/line-lore 0.0.7 → 0.0.9

package/dist/index.mjs

@@ -368,25 +368,6 @@ var init_executor = __esm({
 
 // src/core/ancestry/ancestry.ts
 import { filter as filter4, isTruthy as isTruthy4 } from "@winglet/common-utils";
-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, timeout: budget }
-  );
-  if (firstParentResult) return firstParentResult;
-  const elapsed = Date.now() - startTime;
-  const remaining = budget - elapsed;
-  if (remaining <= 0) return null;
-  return findMergeCommitWithArgs(commitSha, ref, [], {
-    ...options,
-    timeout: remaining
-  });
-}
 async function verifyMergeIntroducesCommit(targetSha, mergeResult, options) {
   if (mergeResult.parentShas.length < 2) return true;
   const firstParent = mergeResult.parentShas[0];
@@ -416,7 +397,7 @@ async function isAncestor(commitA, commitB, options) {
     return null;
   }
 }
-async function findMergeCommitWithArgs(commitSha, ref, extraArgs, options) {
+async function findMergeCommitsWithArgs(commitSha, ref, extraArgs, options) {
   try {
     const result = await gitExec(
       [
@@ -432,28 +413,29 @@ async function findMergeCommitWithArgs(commitSha, ref, extraArgs, options) {
       { cwd: options?.cwd, timeout: options?.timeout }
     );
     const lines = filter4(result.stdout.trim().split("\n"), isTruthy4);
-    if (lines.length === 0) return null;
+    if (lines.length === 0) return [];
+    const verifiedCandidates = [];
     const candidateCount = Math.min(lines.length, MAX_CANDIDATES);
-    let verifiedCount = 0;
+    let attemptedCount = 0;
     for (let i = 0; i < candidateCount; i++) {
       const candidate = parseMergeLogLine(lines[i]);
       if (!candidate) continue;
-      verifiedCount++;
+      attemptedCount++;
       const verified = await verifyMergeIntroducesCommit(
         commitSha,
         candidate,
         options
       );
-      if (verified) return candidate;
+      if (verified) verifiedCandidates.push(candidate);
     }
-    if (verifiedCount > 0 && options?.warnings) {
+    if (attemptedCount > 0 && verifiedCandidates.length === 0 && options?.warnings) {
       options.warnings.push(
-        `ancestry: all ${verifiedCount} merge candidate(s) failed verification for ${commitSha.slice(0, 8)}`
+        `ancestry: all ${attemptedCount} merge candidate(s) failed verification for ${commitSha.slice(0, 8)}`
       );
     }
-    return null;
+    return verifiedCandidates;
   } catch {
-    return null;
+    return [];
   }
 }
 function parseMergeLogLine(line) {
@@ -473,6 +455,38 @@ function parseMergeLogLine(line) {
   const subject = parts.slice(subjectStart).join(" ");
   return { mergeCommitSha, parentShas, subject };
 }
+async function findMergeCommits(commitSha, options) {
+  const ref = options?.ref ?? "HEAD";
+  const budget = options?.timeout ?? DEFAULT_ANCESTRY_TIMEOUT;
+  const startTime = Date.now();
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushUnique = (candidates) => {
+    for (const candidate of candidates) {
+      if (seen.has(candidate.mergeCommitSha)) continue;
+      seen.add(candidate.mergeCommitSha);
+      results.push(candidate);
+      if (results.length >= MAX_CANDIDATES) break;
+    }
+  };
+  const firstParent = await findMergeCommitsWithArgs(
+    commitSha,
+    ref,
+    ["--first-parent"],
+    { ...options, timeout: budget }
+  );
+  pushUnique(firstParent);
+  const elapsed = Date.now() - startTime;
+  const remaining = budget - elapsed;
+  if (remaining > 0 && results.length < MAX_CANDIDATES) {
+    const full = await findMergeCommitsWithArgs(commitSha, ref, [], {
+      ...options,
+      timeout: remaining
+    });
+    pushUnique(full);
+  }
+  return results;
+}
 async function getCommitSubject(sha, options) {
   try {
     const result = await gitExec(["log", "-1", "--format=%s", sha], {
@@ -675,16 +689,17 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
     }
   }
   let mergeBasedPR = null;
-  const mergeResult = await findMergeCommit(commitSha, options);
-  if (mergeResult) {
+  const mergeCandidates = await findMergeCommits(commitSha, options);
+  const hasAncestryMerges = mergeCandidates.length > 0;
+  for (const candidate of mergeCandidates) {
     const prNumber = extractPRFromMergeMessage(
-      mergeResult.subject,
+      candidate.subject,
       options?.platform
     );
     if (prNumber) {
       if (adapter) {
         const prInfo = await adapter.getPRForCommit(
-          mergeResult.mergeCommitSha,
+          candidate.mergeCommitSha,
           prSelectOptions
         );
         if (prInfo?.mergedAt) {
@@ -694,23 +709,32 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
       if (!mergeBasedPR) {
         mergeBasedPR = {
           number: prNumber,
-          title: mergeResult.subject,
+          title: candidate.subject,
           author: "",
           url: "",
-          mergeCommit: mergeResult.mergeCommitSha,
+          mergeCommit: candidate.mergeCommitSha,
           baseBranch: "",
           resolvedVia: "ancestry"
         };
       }
-      if (!options?.deep || mergeBasedPR.mergedAt) {
-        await cache.set(commitSha, toCachedPR(mergeBasedPR));
-        return mergeBasedPR;
+      break;
+    }
+    if (adapter) {
+      const mergeCommitPR = await adapter.getPRForCommit(
+        candidate.mergeCommitSha,
+        prSelectOptions
+      );
+      if (mergeCommitPR?.mergedAt) {
+        mergeBasedPR = { ...mergeCommitPR, resolvedVia: "ancestry" };
+        break;
       }
     }
   }
   if (mergeBasedPR) {
-    await cache.set(commitSha, toCachedPR(mergeBasedPR));
-    return mergeBasedPR;
+    if (!options?.deep || mergeBasedPR.mergedAt) {
+      await cache.set(commitSha, toCachedPR(mergeBasedPR));
+      return mergeBasedPR;
+    }
   }
   const commitSubject = await getCommitSubject(commitSha, options);
   if (commitSubject) {
@@ -732,7 +756,7 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
       return subjectPR;
     }
   }
-  if (!options?.skipPatchIdScan && _recursionDepth < MAX_RECURSION_DEPTH) {
+  if (!options?.skipPatchIdScan && _recursionDepth < MAX_RECURSION_DEPTH && (!hasAncestryMerges || options?.deep)) {
     const patchIdMatch = await findPatchIdMatch(commitSha, {
       ...options,
       scanDepth: options?.deep ? DEEP_SCAN_DEPTH : void 0
@@ -750,6 +774,10 @@ async function lookupPR(commitSha, adapter, options, _recursionDepth = 0) {
       }
     }
   }
+  if (mergeBasedPR) {
+    await cache.set(commitSha, toCachedPR(mergeBasedPR));
+    return mergeBasedPR;
+  }
   return null;
 }
 function resetPRCache() {
@@ -2058,6 +2086,7 @@ function parsePorcelainOutput(output) {
     }
     let commitHash = headerMatch[1];
     const originalLine = parseInt(headerMatch[2], 10);
+    const finalLine = parseInt(headerMatch[3], 10) || 0;
     const isBoundary = commitHash.startsWith("^");
     if (isBoundary) {
       commitHash = commitHash.slice(1).padStart(40, "0");
@@ -2101,6 +2130,7 @@ function parsePorcelainOutput(output) {
       authorEmail: cleanEmail,
       date,
       lineContent,
+      finalLine,
       originalFile,
       originalLine: originalFile ? originalLine : void 0
     });
@@ -2111,14 +2141,112 @@ function parsePorcelainOutput(output) {
 // src/core/blame/blame.ts
 async function executeBlame(file, lineRange, options) {
   const lineSpec = `${lineRange.start},${lineRange.end}`;
-  const result = await gitExec(
-    ["blame", "-w", "-C", "-C", "-M", "--porcelain", "-L", lineSpec, file],
-    options
-  );
+  const args = options?.mode === "change" ? ["blame", "-w", "--porcelain", "-L", lineSpec, file] : ["blame", "-w", "-C", "-C", "-M", "--porcelain", "-L", lineSpec, file];
+  const result = await gitExec(args, options);
   return parsePorcelainOutput(result.stdout);
 }
-async function analyzeBlameResults(results, filePath, options) {
-  const uniqueShas = [...new Set(map6(results, (r) => r.commitHash))];
+async function executeDualBlame(file, lineRange, options) {
+  if (options?.mode === "change") {
+    const results = await executeBlame(file, lineRange, options);
+    return { blame: results, changeBlame: [] };
+  }
+  const [originResult, changeResult] = await Promise.allSettled([
+    executeBlame(file, lineRange, options),
+    executeBlame(file, lineRange, { ...options, mode: "change" })
+  ]);
+  const blame = originResult.status === "fulfilled" ? originResult.value : [];
+  const changeBlame = changeResult.status === "fulfilled" ? changeResult.value : [];
+  if (originResult.status === "rejected") {
+    throw originResult.reason;
+  }
+  return { blame, changeBlame };
+}
+async function verifyRename(originalFile, currentFile, options) {
+  try {
+    const result = await gitExec(
+      [
+        "log",
+        "--diff-filter=R",
+        "--find-renames",
+        "--format=%H",
+        "--",
+        originalFile,
+        currentFile
+      ],
+      options
+    );
+    return result.stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function crossValidateBlame(originResults, changeResults) {
+  const changeMap = /* @__PURE__ */ new Map();
+  for (const r of changeResults) {
+    changeMap.set(r.finalLine, r);
+  }
+  const validated = [];
+  const crossValidatedFlags = [];
+  const changeFallbackFlags = [];
+  const renameChecks = [];
+  for (let i = 0; i < originResults.length; i++) {
+    const origin = originResults[i];
+    const change = changeMap.get(origin.finalLine);
+    if (!change) {
+      validated.push(origin);
+      crossValidatedFlags.push(false);
+      changeFallbackFlags.push(false);
+      continue;
+    }
+    if (origin.commitHash === change.commitHash) {
+      validated.push(origin);
+      crossValidatedFlags.push(true);
+      changeFallbackFlags.push(false);
+      continue;
+    }
+    if (origin.originalFile) {
+      renameChecks.push({
+        originalFile: origin.originalFile,
+        lineIndex: i
+      });
+    }
+    validated.push(change);
+    crossValidatedFlags.push(true);
+    changeFallbackFlags.push(true);
+  }
+  return { validated, renameChecks, crossValidatedFlags, changeFallbackFlags };
+}
+async function analyzeBlameResults(results, filePath, options, changeResults) {
+  let effectiveResults = results;
+  let crossValidatedFlags;
+  let changeFallbackFlagsResult;
+  if (changeResults && changeResults.length > 0) {
+    const { validated, renameChecks, crossValidatedFlags: cvFlags, changeFallbackFlags } = crossValidateBlame(results, changeResults);
+    if (renameChecks.length > 0) {
+      const pendingChecks = /* @__PURE__ */ new Map();
+      for (const check of renameChecks) {
+        const cacheKey = `${check.originalFile}:${filePath}`;
+        if (!pendingChecks.has(cacheKey)) {
+          pendingChecks.set(cacheKey, verifyRename(check.originalFile, filePath, options));
+        }
+      }
+      const renameResults = /* @__PURE__ */ new Map();
+      for (const [key, promise] of pendingChecks) {
+        renameResults.set(key, await promise);
+      }
+      for (const check of renameChecks) {
+        const cacheKey = `${check.originalFile}:${filePath}`;
+        if (renameResults.get(cacheKey)) {
+          validated[check.lineIndex] = results[check.lineIndex];
+          changeFallbackFlags[check.lineIndex] = false;
+        }
+      }
+    }
+    effectiveResults = validated;
+    crossValidatedFlags = cvFlags;
+    changeFallbackFlagsResult = changeFallbackFlags;
+  }
+  const uniqueShas = [...new Set(map6(effectiveResults, (r) => r.commitHash))];
   const cosmeticMap = /* @__PURE__ */ new Map();
   const zeroSha = "0".repeat(40);
   const tasks = [];
@@ -2127,7 +2255,7 @@ async function analyzeBlameResults(results, filePath, options) {
     tasks.push(
       (async () => {
         try {
-          const blameResult = results.find((r) => r.commitHash === sha);
+          const blameResult = effectiveResults.find((r) => r.commitHash === sha);
           if (!blameResult) return;
           const file = blameResult.originalFile ?? filePath;
           const diff = await getCosmeticDiff(sha, file, options);
@@ -2139,12 +2267,14 @@ async function analyzeBlameResults(results, filePath, options) {
     );
   });
   await Promise.all(tasks);
-  return map6(results, (blame) => {
+  return map6(effectiveResults, (blame, i) => {
     const cosmetic = cosmeticMap.get(blame.commitHash);
     return {
       blame,
       isCosmetic: cosmetic?.isCosmetic ?? false,
-      cosmeticReason: cosmetic?.reason
+      cosmeticReason: cosmetic?.reason,
+      crossValidated: crossValidatedFlags?.[i],
+      usedChangeFallback: changeFallbackFlagsResult?.[i]
     };
   });
 }
@@ -2325,8 +2455,11 @@ async function runBlameAndAuth(adapter, options, execOptions) {
   const lineRange = parseLineRange(
     options.endLine ? `${options.line},${options.endLine}` : `${options.line}`
   );
-  const blameChain = executeBlame(options.file, lineRange, execOptions).then(
-    (results) => analyzeBlameResults(results, options.file, execOptions)
+  const blameChain = executeDualBlame(options.file, lineRange, {
+    ...execOptions,
+    mode: options.mode
+  }).then(
+    ({ blame, changeBlame }) => analyzeBlameResults(blame, options.file, execOptions, changeBlame.length > 0 ? changeBlame : void 0)
   );
   const [authResult, blameResult] = await Promise.allSettled([
     adapter ? adapter.checkAuth() : Promise.resolve({ authenticated: false }),
@@ -2348,12 +2481,24 @@ async function runBlameAndAuth(adapter, options, execOptions) {
   }
   return { analyzed: blameResult.value, operatingLevel, warnings };
 }
-async function processEntry(entry, featureFlags, adapter, options, execOptions, repoId, skipPatchIdScan, preferredBase) {
+function resolveTraceMode(mode) {
+  return mode ?? "origin";
+}
+function deduplicatedLookupPR(sha, adapter, options, inflight) {
+  const existing = inflight.get(sha);
+  if (existing) return existing;
+  const promise = lookupPR(sha, adapter, options);
+  inflight.set(sha, promise);
+  promise.finally(() => inflight.delete(sha));
+  return promise;
+}
+async function processEntry(entry, featureFlags, adapter, options, execOptions, repoId, inflightPR, skipPatchIdScan, preferredBase) {
   const nodes = [];
+  const traceMode = resolveTraceMode(options.mode);
   const commitNode = {
     type: entry.isCosmetic ? "cosmetic_commit" : "original_commit",
     sha: entry.blame.commitHash,
-    trackingMethod: "blame-CMw",
+    trackingMethod: traceMode === "change" || entry.usedChangeFallback ? "blame" : "blame-CMw",
     confidence: "exact",
     note: entry.cosmeticReason ? `Cosmetic change: ${entry.cosmeticReason}` : void 0
   };
@@ -2375,17 +2520,18 @@ async function processEntry(entry, featureFlags, adapter, options, execOptions,
     }
   }
   const targetSha = nodes[nodes.length - 1].sha;
+  const prLookupOptions = {
+    ...execOptions,
+    noCache: options.noCache,
+    cacheOnly: options.cacheOnly,
+    deep: featureFlags.deepTrace,
+    repoId,
+    skipPatchIdScan,
+    preferredBase,
+    platform: adapter?.platform
+  };
   if (targetSha) {
-    const prInfo = await lookupPR(targetSha, adapter, {
-      ...execOptions,
-      noCache: options.noCache,
-      cacheOnly: options.cacheOnly,
-      deep: featureFlags.deepTrace,
-      repoId,
-      skipPatchIdScan,
-      preferredBase,
-      platform: adapter?.platform
-    });
+    const prInfo = await deduplicatedLookupPR(targetSha, adapter, prLookupOptions, inflightPR);
     if (prInfo) {
       nodes.push({
         type: "pull_request",
@@ -2402,6 +2548,7 @@ async function processEntry(entry, featureFlags, adapter, options, execOptions,
   return nodes;
 }
 async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOptions, repoId, skipPatchIdScan, preferredBase) {
+  const inflightPR = /* @__PURE__ */ new Map();
   const results = await Promise.allSettled(
     map8(
       analyzed,
@@ -2412,6 +2559,7 @@ async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOpt
         options,
         execOptions,
         repoId,
+        inflightPR,
         skipPatchIdScan,
         preferredBase
       )
@@ -2421,6 +2569,7 @@ async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOpt
 }
 var legacyCacheCleaned = false;
 async function trace(options) {
+  const mode = resolveTraceMode(options.mode);
   const { file, cwd } = await resolveFileContext(options.file, options.cwd);
   const warnings = [];
   const execOptions = { cwd, warnings };
@@ -2442,7 +2591,7 @@ async function trace(options) {
   }
   const blameAuth = await runBlameAndAuth(
     platform.adapter,
-    { ...options, file, cwd },
+    { ...options, mode, file, cwd },
     execOptions
   );
   const operatingLevel = blameAuth.operatingLevel || platform.operatingLevel;
@@ -2485,7 +2634,7 @@ async function trace(options) {
     blameAuth.analyzed,
     featureFlags,
     platform.adapter,
-    { ...options, file, cwd },
+    { ...options, mode, file, cwd },
     execOptions,
     repoId,
     cloneStatus.partialClone || void 0,

package/dist/types/blame.d.ts

@@ -12,11 +12,23 @@ export interface BlameResult {
     date: string;
     /** The actual content of the blamed line */
     lineContent: string;
+    /** Final line number in the current file */
+    finalLine: number;
     /** Original filename if the line was moved/renamed */
     originalFile?: string;
     /** Original line number before any moves/renames */
     originalLine?: number;
 }
+/**
+ * Result of running dual blame (origin + change) in parallel.
+ * Used by origin mode to cross-validate blame results.
+ */
+export interface DualBlameResult {
+    /** Primary blame results for the requested mode */
+    blame: BlameResult[];
+    /** Change-mode blame for cross-validation (populated only in origin mode) */
+    changeBlame: BlameResult[];
+}
 /**
  * Basic commit information from git log.
  */

package/dist/types/git.d.ts

@@ -1,4 +1,5 @@
 import type { PlatformType } from './platform.js';
+import type { TraceMode } from './trace.js';
 export interface GitExecResult {
     stdout: string;
     stderr: string;
@@ -11,6 +12,10 @@ export interface GitExecOptions {
     /** Mutable array for collecting diagnostic warnings throughout the pipeline */
     warnings?: string[];
 }
+export interface BlameExecOptions extends GitExecOptions {
+    /** Blame semantics used by trace mode selection */
+    mode?: TraceMode;
+}
 export interface RemoteInfo {
     owner: string;
     repo: string;

package/dist/types/index.d.ts

@@ -1,11 +1,11 @@
 export type { SymbolKind, SymbolInfo, ContentHash, ChangeType, ComparisonResult, AstTraceResult, } from './ast.js';
-export type { BlameResult, CommitInfo } from './blame.js';
+export type { BlameResult, CommitInfo, DualBlameResult } from './blame.js';
 export type { CacheEntry, CachedPRInfo } from './cache.js';
-export type { GitExecResult, GitExecOptions, RemoteInfo, HealthReport, CloneStatus, } from './git.js';
+export type { GitExecResult, GitExecOptions, BlameExecOptions, RemoteInfo, HealthReport, CloneStatus, } from './git.js';
 export type { GraphOptions, GraphResult } from './graph.js';
 export type { NormalizedResponse } from './output.js';
 export type { TraceNodeType, TrackingMethod, Confidence, TraceNode, OperatingLevel, FeatureFlags, } from './pipeline.js';
 export type { PlatformType, AuthStatus, PRInfo, IssueInfo, RateLimitInfo, PlatformAdapter, } from './platform.js';
 export type { CosmeticReason, BlameStageResult, AstDiffStageResult, } from './stage.js';
-export type { TraceResult, TraceOptions } from './trace.js';
+export type { TraceMode, TraceResult, TraceOptions } from './trace.js';
 export type { LineRange } from './util.js';

package/dist/types/stage.d.ts

@@ -6,6 +6,10 @@ export interface BlameStageResult {
     blame: BlameResult;
     isCosmetic: boolean;
     cosmeticReason?: CosmeticReason;
+    /** Whether this result was cross-validated against change blame (origin mode only) */
+    crossValidated?: boolean;
+    /** Whether the change blame result was used instead of origin (false positive filtered) */
+    usedChangeFallback?: boolean;
 }
 export interface AstDiffStageResult {
     originalSha: string;

package/dist/types/trace.d.ts

@@ -9,6 +9,7 @@ export interface TraceResult {
     /** PR information if found, null if commit is not from a PR */
     pr: PRInfo | null;
 }
+export type TraceMode = 'origin' | 'change';
 /**
  * Options for the trace operation (library API).
  */
@@ -31,4 +32,6 @@ export interface TraceOptions {
     noCache?: boolean;
     /** Return cached results only — skip API calls, ancestry traversal, and patch-id scan */
     cacheOnly?: boolean;
+    /** Trace mode. `origin` follows copy/move history, `change` finds the last meaningful local change. */
+    mode?: TraceMode;
 }

package/dist/version.d.ts

@@ -2,4 +2,4 @@
  * Current package version from package.json
  * Automatically synchronized during build process
  */
-export declare const VERSION = "0.0.7";
+export declare const VERSION = "0.0.9";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumy-pack/line-lore",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "CLI tool for tracing code lines to their originating Pull Requests via git blame",
   "keywords": [
     "cli",