@fern-api/generator-cli 0.9.0 → 0.9.2

package/dist/cli.js

@@ -19759,7 +19759,7 @@ var init_diff3 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@fern-api+replay@0.9.0/node_modules/@fern-api/replay/dist/index.js
+// ../../node_modules/.pnpm/@fern-api+replay@0.9.1/node_modules/@fern-api/replay/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
   FERN_BOT_EMAIL: () => FERN_BOT_EMAIL2,
@@ -19784,6 +19784,241 @@ __export(dist_exports, {
   status: () => status,
   threeWayMerge: () => threeWayMerge
 });
+function parseHunks(fileDiff) {
+  const lines = fileDiff.split("\n");
+  const hunks = [];
+  let currentHunk = null;
+  for (const line of lines) {
+    const headerMatch = line.match(
+      /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/
+    );
+    if (headerMatch) {
+      if (currentHunk) {
+        hunks.push(currentHunk);
+      }
+      currentHunk = {
+        oldStart: parseInt(headerMatch[1], 10),
+        oldCount: headerMatch[2] != null ? parseInt(headerMatch[2], 10) : 1,
+        newStart: parseInt(headerMatch[3], 10),
+        newCount: headerMatch[4] != null ? parseInt(headerMatch[4], 10) : 1,
+        lines: []
+      };
+      continue;
+    }
+    if (!currentHunk) continue;
+    if (line.startsWith("diff --git") || line.startsWith("index ") || line.startsWith("---") || line.startsWith("+++") || line.startsWith("old mode") || line.startsWith("new mode") || line.startsWith("similarity index") || line.startsWith("rename from") || line.startsWith("rename to") || line.startsWith("new file mode") || line.startsWith("deleted file mode")) {
+      continue;
+    }
+    if (line === "\") {
+      continue;
+    }
+    if (line.startsWith("-")) {
+      currentHunk.lines.push({ type: "remove", content: line.slice(1) });
+    } else if (line.startsWith("+")) {
+      currentHunk.lines.push({ type: "add", content: line.slice(1) });
+    } else if (line.startsWith(" ") || line === "") {
+      currentHunk.lines.push({
+        type: "context",
+        content: line.startsWith(" ") ? line.slice(1) : line
+      });
+    }
+  }
+  if (currentHunk) {
+    hunks.push(currentHunk);
+  }
+  return hunks;
+}
+function extractLeadingContext(hunk) {
+  const result = [];
+  for (const line of hunk.lines) {
+    if (line.type !== "context") break;
+    result.push(line.content);
+  }
+  return result;
+}
+function extractTrailingContext(hunk) {
+  const result = [];
+  for (let i = hunk.lines.length - 1; i >= 0; i--) {
+    if (hunk.lines[i].type !== "context") break;
+    result.unshift(hunk.lines[i].content);
+  }
+  return result;
+}
+function countOursLinesBeforeTrailing(hunk) {
+  let count = 0;
+  const trailingStart = findTrailingContextStart(hunk);
+  for (let i = 0; i < trailingStart; i++) {
+    if (hunk.lines[i].type === "context") count++;
+  }
+  return count;
+}
+function findTrailingContextStart(hunk) {
+  let i = hunk.lines.length - 1;
+  while (i >= 0 && hunk.lines[i].type === "context") {
+    i--;
+  }
+  return i + 1;
+}
+function matchesAt(needle, haystack, offset) {
+  for (let i = 0; i < needle.length; i++) {
+    if (haystack[offset + i] !== needle[i]) return false;
+  }
+  return true;
+}
+function findContextInOurs(contextLines, oursLines, minIndex, hint) {
+  const SEARCH_WINDOW = 200;
+  const maxStart = oursLines.length - contextLines.length;
+  const clampedHint = Math.max(minIndex, Math.min(hint, maxStart));
+  if (clampedHint >= minIndex && clampedHint <= maxStart) {
+    if (matchesAt(contextLines, oursLines, clampedHint)) {
+      return clampedHint;
+    }
+  }
+  for (let delta = 1; delta <= SEARCH_WINDOW; delta++) {
+    for (const sign of [1, -1]) {
+      const idx = clampedHint + delta * sign;
+      if (idx < minIndex || idx > maxStart) continue;
+      if (matchesAt(contextLines, oursLines, idx)) {
+        return idx;
+      }
+    }
+  }
+  return -1;
+}
+function computeOursSpan(hunk, oursLines, oursOffset) {
+  const leading = extractLeadingContext(hunk);
+  const trailing = extractTrailingContext(hunk);
+  if (trailing.length === 0) {
+    const contextCount2 = hunk.lines.filter(
+      (l) => l.type === "context"
+    ).length;
+    return Math.min(contextCount2, oursLines.length - oursOffset);
+  }
+  const searchStart = oursOffset + leading.length;
+  for (let i = searchStart; i <= oursLines.length - trailing.length; i++) {
+    if (matchesAt(trailing, oursLines, i)) {
+      return i + trailing.length - oursOffset;
+    }
+  }
+  const contextCount = hunk.lines.filter(
+    (l) => l.type === "context"
+  ).length;
+  return Math.min(contextCount, oursLines.length - oursOffset);
+}
+function locateHunksInOurs(hunks, oursLines) {
+  const located = [];
+  let minOursIndex = 0;
+  for (const hunk of hunks) {
+    const contextLines = extractLeadingContext(hunk);
+    let oursOffset;
+    if (contextLines.length > 0) {
+      const found = findContextInOurs(
+        contextLines,
+        oursLines,
+        minOursIndex,
+        hunk.newStart - 1
+      );
+      if (found === -1) {
+        const trailingContext = extractTrailingContext(hunk);
+        if (trailingContext.length > 0) {
+          const trailingFound = findContextInOurs(
+            trailingContext,
+            oursLines,
+            minOursIndex,
+            hunk.newStart - 1
+          );
+          if (trailingFound === -1) return null;
+          const nonTrailingCount = countOursLinesBeforeTrailing(hunk);
+          oursOffset = trailingFound - nonTrailingCount;
+          if (oursOffset < minOursIndex) return null;
+        } else {
+          return null;
+        }
+      } else {
+        oursOffset = found;
+      }
+    } else if (hunk.oldStart === 1 && hunk.oldCount === 0) {
+      oursOffset = 0;
+    } else {
+      oursOffset = Math.max(hunk.newStart - 1, minOursIndex);
+    }
+    const oursSpan = computeOursSpan(hunk, oursLines, oursOffset);
+    located.push({ hunk, oursOffset, oursSpan });
+    minOursIndex = oursOffset + oursSpan;
+  }
+  return located;
+}
+function assembleHybrid(locatedHunks, oursLines) {
+  const baseLines = [];
+  const theirsLines = [];
+  let oursCursor = 0;
+  for (const { hunk, oursOffset, oursSpan } of locatedHunks) {
+    if (oursOffset > oursCursor) {
+      const gapLines = oursLines.slice(oursCursor, oursOffset);
+      baseLines.push(...gapLines);
+      theirsLines.push(...gapLines);
+    }
+    for (const line of hunk.lines) {
+      switch (line.type) {
+        case "context":
+          baseLines.push(line.content);
+          theirsLines.push(line.content);
+          break;
+        case "remove":
+          baseLines.push(line.content);
+          break;
+        case "add":
+          theirsLines.push(line.content);
+          break;
+      }
+    }
+    oursCursor = oursOffset + oursSpan;
+  }
+  if (oursCursor < oursLines.length) {
+    const gapLines = oursLines.slice(oursCursor);
+    baseLines.push(...gapLines);
+    theirsLines.push(...gapLines);
+  }
+  return {
+    base: baseLines.join("\n"),
+    theirs: theirsLines.join("\n")
+  };
+}
+function reconstructFromGhostPatch(fileDiff, ours) {
+  const hunks = parseHunks(fileDiff);
+  if (hunks.length === 0) {
+    return null;
+  }
+  const isPureAddition = hunks.every(
+    (h) => h.oldCount === 0 && h.lines.every((l) => l.type !== "remove")
+  );
+  if (isPureAddition) {
+    return null;
+  }
+  const isPureDeletion = hunks.every(
+    (h) => h.newCount === 0 && h.lines.every((l) => l.type !== "add")
+  );
+  if (isPureDeletion) {
+    const baseLines = [];
+    for (const hunk of hunks) {
+      for (const line of hunk.lines) {
+        if (line.type === "context" || line.type === "remove") {
+          baseLines.push(line.content);
+        }
+      }
+    }
+    return {
+      base: baseLines.join("\n"),
+      theirs: ""
+    };
+  }
+  const oursLines = ours.split("\n");
+  const located = locateHunksInOurs(hunks, oursLines);
+  if (!located) {
+    return null;
+  }
+  return assembleHybrid(located, oursLines);
+}
 function isGenerationCommit(commit) {
   const isFernSupport = FERN_SUPPORT_NAMES.includes(commit.authorName);
   const isBotAuthor = !isFernSupport && (commit.authorLogin === FERN_BOT_LOGIN2 || commit.authorEmail === FERN_BOT_EMAIL2 || commit.authorName === FERN_BOT_NAME2);
@@ -19957,6 +20192,7 @@ async function bootstrap(outputDir, options) {
   }
   lockManager.save();
   const fernignoreUpdated = ensureFernignoreEntries(outputDir);
+  ensureGitattributesEntries(outputDir);
   if (migrator.fernignoreExists() && fernignorePatterns.length > 0) {
     const action = options?.fernignoreAction ?? "skip";
     if (action === "migrate") {
@@ -20061,6 +20297,28 @@ function ensureFernignoreEntries(outputDir) {
   (0, import_fs9.writeFileSync)(fernignorePath, content, "utf-8");
   return true;
 }
+function ensureGitattributesEntries(outputDir) {
+  const gitattributesPath = (0, import_path12.join)(outputDir, ".gitattributes");
+  let content = "";
+  if ((0, import_fs9.existsSync)(gitattributesPath)) {
+    content = (0, import_fs9.readFileSync)(gitattributesPath, "utf-8");
+  }
+  const lines = content.split("\n");
+  const toAdd = [];
+  for (const entry of GITATTRIBUTES_ENTRIES) {
+    if (!lines.some((line) => line.trim() === entry)) {
+      toAdd.push(entry);
+    }
+  }
+  if (toAdd.length === 0) {
+    return;
+  }
+  if (content && !content.endsWith("\n")) {
+    content += "\n";
+  }
+  content += toAdd.join("\n") + "\n";
+  (0, import_fs9.writeFileSync)(gitattributesPath, content, "utf-8");
+}
 function computeContentHash(patchContent) {
   const normalized = patchContent.split("\n").filter((line) => !line.startsWith("From ") && !line.startsWith("index ") && !line.startsWith("Date: ")).join("\n");
   return `sha256:${(0, import_crypto3.createHash)("sha256").update(normalized).digest("hex")}`;
@@ -20352,9 +20610,9 @@ function status(outputDir) {
     excludePatterns
   };
 }
-var import_fs6, import_path8, import_yaml, import_crypto, import_promises4, import_os, import_path9, import_fs7, import_path10, import_crypto2, import_fs8, import_path11, import_yaml2, import_crypto3, import_fs9, import_path12, import_fs10, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, FERN_BOT_NAME2, FERN_BOT_EMAIL2, FERN_BOT_LOGIN2, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileManager, INFRASTRUCTURE_FILES, ReplayDetector, BINARY_EXTENSIONS, ReplayApplicator, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, EMPTY_RESULT;
+var import_fs6, import_path8, import_yaml, import_crypto, import_promises4, import_os, import_path9, import_fs7, import_path10, import_crypto2, import_fs8, import_path11, import_yaml2, import_crypto3, import_fs9, import_path12, import_fs10, __defProp3, __getOwnPropNames3, __esm3, __export3, GitClient_exports, GitClient, init_GitClient, HybridReconstruction_exports, init_HybridReconstruction, FERN_BOT_NAME2, FERN_BOT_EMAIL2, FERN_BOT_LOGIN2, FERN_SUPPORT_NAMES, LOCKFILE_HEADER, LockfileManager, INFRASTRUCTURE_FILES, ReplayDetector, BINARY_EXTENSIONS, ReplayApplicator, ReplayCommitter, ReplayService, FernignoreMigrator, REPLAY_FERNIGNORE_ENTRIES, GITATTRIBUTES_ENTRIES, EMPTY_RESULT;
 var init_dist = __esm({
-  "../../node_modules/.pnpm/@fern-api+replay@0.9.0/node_modules/@fern-api/replay/dist/index.js"() {
+  "../../node_modules/.pnpm/@fern-api+replay@0.9.1/node_modules/@fern-api/replay/dist/index.js"() {
     "use strict";
     init_esm4();
     import_fs6 = require("fs");
@@ -20488,6 +20746,14 @@ var init_dist = __esm({
               return false;
             }
           }
+          async treeExists(treeHash) {
+            try {
+              const type = await this.exec(["cat-file", "-t", treeHash]);
+              return type.trim() === "tree";
+            } catch {
+              return false;
+            }
+          }
           async getCommitBody(commitSha) {
             return this.exec(["log", "-1", "--format=%B", commitSha]);
           }
@@ -20497,6 +20763,18 @@ var init_dist = __esm({
         };
       }
     });
+    HybridReconstruction_exports = {};
+    __export3(HybridReconstruction_exports, {
+      assembleHybrid: () => assembleHybrid,
+      locateHunksInOurs: () => locateHunksInOurs,
+      parseHunks: () => parseHunks,
+      reconstructFromGhostPatch: () => reconstructFromGhostPatch
+    });
+    init_HybridReconstruction = __esm3({
+      "src/HybridReconstruction.ts"() {
+        "use strict";
+      }
+    });
     init_GitClient();
     FERN_BOT_NAME2 = "fern-api";
     FERN_BOT_EMAIL2 = "115122769+fern-api[bot]@users.noreply.github.com";
@@ -20883,6 +21161,7 @@ var init_dist = __esm({
       lockManager;
       outputDir;
       renameCache = /* @__PURE__ */ new Map();
+      treeExistsCache = /* @__PURE__ */ new Map();
       fileTheirsAccumulator = /* @__PURE__ */ new Map();
       constructor(git, lockManager, outputDir) {
         this.git = git;
@@ -21079,14 +21358,33 @@ var init_dist = __esm({
           }
           const oursPath = (0, import_path9.join)(this.outputDir, resolvedPath);
           const ours = await (0, import_promises4.readFile)(oursPath, "utf-8").catch(() => null);
-          let theirs = await this.applyPatchToContent(
-            base,
-            patch.patch_content,
-            filePath,
-            tempGit,
-            tempDir,
-            renameSourcePath
-          );
+          let ghostReconstructed = false;
+          let theirs = null;
+          if (!base && ours && !renameSourcePath) {
+            const treeReachable = await this.isTreeReachable(baseGen.tree_hash);
+            if (!treeReachable) {
+              const fileDiff = this.extractFileDiff(patch.patch_content, filePath);
+              if (fileDiff) {
+                const { reconstructFromGhostPatch: reconstructFromGhostPatch2 } = await Promise.resolve().then(() => (init_HybridReconstruction(), HybridReconstruction_exports));
+                const result = reconstructFromGhostPatch2(fileDiff, ours);
+                if (result) {
+                  base = result.base;
+                  theirs = result.theirs;
+                  ghostReconstructed = true;
+                }
+              }
+            }
+          }
+          if (!ghostReconstructed) {
+            theirs = await this.applyPatchToContent(
+              base,
+              patch.patch_content,
+              filePath,
+              tempGit,
+              tempDir,
+              renameSourcePath
+            );
+          }
           let useAccumulatorAsMergeBase = false;
           const accumulatorEntry = this.fileTheirsAccumulator.get(resolvedPath);
           if (!theirs && accumulatorEntry) {
@@ -21119,13 +21417,13 @@ var init_dist = __esm({
               baseMismatchSkipped = true;
             }
           }
-          if (!base && !ours && effective_theirs) {
+          if (base == null && !ours && effective_theirs) {
             const outDir2 = (0, import_path9.dirname)(oursPath);
             await (0, import_promises4.mkdir)(outDir2, { recursive: true });
             await (0, import_promises4.writeFile)(oursPath, effective_theirs);
             return { file: resolvedPath, status: "merged", reason: "new-file" };
           }
-          if (!base && ours && effective_theirs) {
+          if (base == null && ours && effective_theirs) {
             const merged2 = threeWayMerge("", ours, effective_theirs);
             const outDir2 = (0, import_path9.dirname)(oursPath);
             await (0, import_promises4.mkdir)(outDir2, { recursive: true });
@@ -21148,7 +21446,7 @@ var init_dist = __esm({
               reason: "missing-content"
             };
           }
-          if (!base && !useAccumulatorAsMergeBase || !ours) {
+          if (base == null && !useAccumulatorAsMergeBase || !ours) {
             return {
               file: resolvedPath,
               status: "skipped",
@@ -21191,6 +21489,14 @@ var init_dist = __esm({
           };
         }
       }
+      async isTreeReachable(treeHash) {
+        let result = this.treeExistsCache.get(treeHash);
+        if (result === void 0) {
+          result = await this.git.treeExists(treeHash);
+          this.treeExistsCache.set(treeHash, result);
+        }
+        return result;
+      }
       isExcluded(patch) {
         const config = this.lockManager.getCustomizationsConfig();
         if (!config.exclude) return false;
@@ -22157,7 +22463,8 @@ CLI Version: ${options.cliVersion}`;
       }
     };
     init_GitClient();
-    REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml"];
+    REPLAY_FERNIGNORE_ENTRIES = [".fern/replay.lock", ".fern/replay.yml", ".gitattributes"];
+    GITATTRIBUTES_ENTRIES = [".fern/replay.lock linguist-generated=true"];
     EMPTY_RESULT = {
       initialized: false,
       removed: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fern-api/generator-cli",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",
@@ -22,7 +22,7 @@
     "**"
   ],
   "dependencies": {
-    "@fern-api/replay": "^0.9.0",
+    "@fern-api/replay": "^0.9.1",
     "@octokit/rest": "^22.0.1",
     "es-toolkit": "^1.45.1",
     "tmp-promise": "^3.0.3"