mobbdev 1.2.6 → 1.2.8

package/dist/index.mjs

@@ -846,13 +846,12 @@ var init_client_generates = __esm({
 }
     `;
     AnalyzeCommitForExtensionAiBlameDocument = `
-    mutation AnalyzeCommitForExtensionAIBlame($repositoryURL: String!, $commitSha: String!, $organizationId: String!, $commitTimestamp: Timestamp, $parentCommits: [ParentCommitInput!]) {
+    mutation AnalyzeCommitForExtensionAIBlame($repositoryURL: String!, $commitSha: String!, $organizationId: String!, $commitTimestamp: Timestamp) {
   analyzeCommitForAIBlame(
     repositoryURL: $repositoryURL
     commitSha: $commitSha
     organizationId: $organizationId
     commitTimestamp: $commitTimestamp
-    parentCommits: $parentCommits
   ) {
     __typename
     ... on ProcessAIBlameFinalResult {
@@ -3801,34 +3800,6 @@ ${rootContent}`;
           throw new Error(errorMessage);
         }
       }
-      /**
-       * Gets timestamps for parent commits in a single git call.
-       * @param parentShas Array of parent commit SHAs
-       * @returns Array of parent commits with timestamps, or undefined if unavailable
-       */
-      async getParentCommitTimestamps(parentShas) {
-        if (parentShas.length === 0) {
-          return void 0;
-        }
-        try {
-          const output = await this.git.raw([
-            "log",
-            "--format=%H %cI",
-            "--no-walk",
-            ...parentShas
-          ]);
-          const parentCommits = output.trim().split("\n").filter(Boolean).map((line) => {
-            const [sha, ts] = line.split(" ");
-            return { sha: sha ?? "", timestamp: new Date(ts ?? "") };
-          }).filter((p) => p.sha !== "");
-          return parentCommits.length > 0 ? parentCommits : void 0;
-        } catch {
-          this.log("[GitService] Could not get parent commit timestamps", "debug", {
-            parentShas
-          });
-          return void 0;
-        }
-      }
       /**
        * Gets local commit data including diff, timestamp, and parent commits.
        * Used by Tracy extension to send commit data directly without requiring SCM token.
@@ -3873,18 +3844,14 @@ ${rootContent}`;
           }
           const timestampStr = metadataLines[0];
           const timestamp = new Date(timestampStr);
-          const parentShas = (metadataLines[1] ?? "").trim().split(/\s+/).filter(Boolean);
-          const parentCommits = await this.getParentCommitTimestamps(parentShas);
           this.log("[GitService] Local commit data retrieved", "debug", {
             commitSha,
             diffSizeBytes,
-            timestamp: timestamp.toISOString(),
-            parentCommitCount: parentCommits?.length ?? 0
+            timestamp: timestamp.toISOString()
           });
           return {
             diff,
-            timestamp,
-            parentCommits
+            timestamp
           };
         } catch (error) {
           const errorMessage = `Failed to get local commit data: ${error.message}`;
@@ -6109,6 +6076,34 @@ var GetReferenceResultZ = z13.object({
   type: z13.nativeEnum(ReferenceType)
 });
 
+// src/features/analysis/scm/utils/diffUtils.ts
+import parseDiff from "parse-diff";
+function parseAddedLinesByFile(diff) {
+  const result = /* @__PURE__ */ new Map();
+  const parsedDiff = parseDiff(diff);
+  for (const file of parsedDiff) {
+    if (!file.to || file.to === "/dev/null") {
+      continue;
+    }
+    const filePath = file.to;
+    const addedLines = [];
+    if (file.chunks) {
+      for (const chunk of file.chunks) {
+        for (const change of chunk.changes) {
+          if (change.type === "add") {
+            const addChange = change;
+            addedLines.push(addChange.ln);
+          }
+        }
+      }
+    }
+    if (addedLines.length > 0) {
+      result.set(filePath, addedLines);
+    }
+  }
+  return result;
+}
+
 // src/features/analysis/scm/utils/scm.ts
 var safeBody = (body, maxBodyLength) => {
   const truncationNotice = "\n\n... Message was cut here because it is too long";
@@ -6201,6 +6196,36 @@ function getCommitIssueUrl(params) {
     analysisId
   })}/commit?${searchParams.toString()}`;
 }
+function extractLinearTicketsFromBody(body, seen) {
+  const tickets = [];
+  const htmlPattern = /<a href="(https:\/\/linear\.app\/[^"]+)">([A-Z]+-\d+)<\/a>/g;
+  let match;
+  while ((match = htmlPattern.exec(body)) !== null) {
+    const ticket = parseLinearTicket(match[1], match[2]);
+    if (ticket && !seen.has(`${ticket.name}|${ticket.url}`)) {
+      seen.add(`${ticket.name}|${ticket.url}`);
+      tickets.push(ticket);
+    }
+  }
+  const markdownPattern = /\[([A-Z]+-\d+)\]\((https:\/\/linear\.app\/[^)]+)\)/g;
+  while ((match = markdownPattern.exec(body)) !== null) {
+    const ticket = parseLinearTicket(match[2], match[1]);
+    if (ticket && !seen.has(`${ticket.name}|${ticket.url}`)) {
+      seen.add(`${ticket.name}|${ticket.url}`);
+      tickets.push(ticket);
+    }
+  }
+  return tickets;
+}
+function parseLinearTicket(url, name) {
+  if (!name || !url) {
+    return null;
+  }
+  const urlParts = url.split("/");
+  const titleSlug = urlParts[urlParts.length - 1] || "";
+  const title = titleSlug.replace(/-/g, " ");
+  return { name, title, url };
+}
 var userNamePattern = /^(https?:\/\/)([^@]+@)?([^/]+\/.+)$/;
 var sshPattern = /^git@([\w.-]+):([\w./-]+)$/;
 function normalizeUrl(repoUrl) {
@@ -6894,9 +6919,6 @@ async function getAdoSdk(params) {
         return commitRes.value;
       }
       throw new RefNotFoundError(`ref: ${ref} does not exist`);
-    },
-    getAdoBlameRanges() {
-      return [];
     }
   };
 }
@@ -7016,7 +7038,6 @@ var SCMLib = class {
    * IMPORTANT: Sort order must remain consistent across paginated requests
    * for cursor-based pagination to work correctly.
    *
-   * Default implementation uses getSubmitRequests and applies filters/sorting in-memory.
    * Override in subclasses for provider-specific optimizations (e.g., GitHub Search API).
    *
    * @param params - Search parameters including filters, sort, and pagination
@@ -7098,6 +7119,14 @@ var SCMLib = class {
   static async getIsValidBranchName(branchName) {
     return isValidBranchName(branchName);
   }
+  /**
+   * Extract Linear ticket links from PR/MR comments.
+   * Default implementation returns empty array - subclasses can override.
+   * Public so it can be reused by backend services.
+   */
+  extractLinearTicketsFromComments(_comments) {
+    return [];
+  }
   _validateAccessTokenAndUrl() {
     this._validateAccessToken();
     this._validateUrl();
@@ -7250,10 +7279,6 @@ var AdoSCMLib = class extends SCMLib {
         throw new Error(`unknown state ${state}`);
     }
   }
-  async getRepoBlameRanges(_ref, _path) {
-    const adoSdk = await this.getAdoSdk();
-    return await adoSdk.getAdoBlameRanges();
-  }
   async getReferenceData(ref) {
     this._validateUrl();
     const adoSdk = await this.getAdoSdk();
@@ -7312,9 +7337,6 @@ var AdoSCMLib = class extends SCMLib {
   async getSubmitRequestDiff(_submitRequestId) {
     throw new Error("getSubmitRequestDiff not implemented for ADO");
   }
-  async getSubmitRequests(_repoUrl) {
-    throw new Error("getSubmitRequests not implemented for ADO");
-  }
   async searchSubmitRequests(_params) {
     throw new Error("searchSubmitRequests not implemented for ADO");
   }
@@ -7326,6 +7348,12 @@ var AdoSCMLib = class extends SCMLib {
   async getPullRequestMetrics(_prNumber) {
     throw new Error("getPullRequestMetrics not implemented for ADO");
   }
+  async getRecentCommits(_since) {
+    throw new Error("getRecentCommits not implemented for ADO");
+  }
+  async getRateLimitStatus() {
+    return null;
+  }
 };
 
 // src/features/analysis/scm/bitbucket/bitbucket.ts
@@ -7843,9 +7871,6 @@ var BitbucketSCMLib = class extends SCMLib {
         throw new Error(`unknown state ${pullRequestRes.state} `);
     }
   }
-  async getRepoBlameRanges(_ref, _path) {
-    return [];
-  }
   async getReferenceData(ref) {
     this._validateUrl();
     return this.bitbucketSdk.getReferenceData({ url: this.url, ref });
@@ -7894,9 +7919,6 @@ var BitbucketSCMLib = class extends SCMLib {
   async getSubmitRequestDiff(_submitRequestId) {
     throw new Error("getSubmitRequestDiff not implemented for Bitbucket");
   }
-  async getSubmitRequests(_repoUrl) {
-    throw new Error("getSubmitRequests not implemented for Bitbucket");
-  }
   async searchSubmitRequests(_params) {
     throw new Error("searchSubmitRequests not implemented for Bitbucket");
   }
@@ -7908,6 +7930,12 @@ var BitbucketSCMLib = class extends SCMLib {
   async getPullRequestMetrics(_prNumber) {
     throw new Error("getPullRequestMetrics not implemented for Bitbucket");
   }
+  async getRecentCommits(_since) {
+    throw new Error("getRecentCommits not implemented for Bitbucket");
+  }
+  async getRateLimitStatus() {
+    return null;
+  }
 };
 
 // src/features/analysis/scm/constants.ts
@@ -7920,7 +7948,7 @@ init_env();
 
 // src/features/analysis/scm/github/GithubSCMLib.ts
 init_env();
-import pLimit2 from "p-limit";
+import pLimit from "p-limit";
 import { z as z21 } from "zod";
 init_client_generates();
 
@@ -7939,59 +7967,6 @@ function parseCursorSafe(cursor, defaultValue = 0, maxValue = MAX_CURSOR_VALUE)
 
 // src/features/analysis/scm/github/github.ts
 import { RequestError } from "@octokit/request-error";
-import pLimit from "p-limit";
-
-// src/utils/contextLogger.ts
-import debugModule from "debug";
-var debug3 = debugModule("mobb:shared");
-var _contextLogger = null;
-var createContextLogger = async () => {
-  if (_contextLogger) return _contextLogger;
-  try {
-    let logger2;
-    try {
-      let module;
-      try {
-        const buildPath = "../../../../../tscommon/backend/build/src/utils/logger";
-        module = await import(buildPath);
-      } catch (e) {
-        const sourcePath = "../../../../../tscommon/backend/src/utils/logger";
-        module = await import(sourcePath);
-      }
-      logger2 = module.logger;
-    } catch {
-    }
-    if (logger2) {
-      _contextLogger = {
-        info: (message, data) => data ? logger2.info(data, message) : logger2.info(message),
-        debug: (message, data) => data ? logger2.debug(data, message) : logger2.debug(message),
-        error: (message, data) => data ? logger2.error(data, message) : logger2.error(message)
-      };
-      return _contextLogger;
-    }
-  } catch {
-  }
-  _contextLogger = {
-    info: (message, data) => debug3(message, data),
-    debug: (message, data) => debug3(message, data),
-    error: (message, data) => debug3(message, data)
-  };
-  return _contextLogger;
-};
-var contextLogger = {
-  info: async (message, data) => {
-    const logger2 = await createContextLogger();
-    return logger2.info(message, data);
-  },
-  debug: async (message, data) => {
-    const logger2 = await createContextLogger();
-    return logger2.debug(message, data);
-  },
-  error: async (message, data) => {
-    const logger2 = await createContextLogger();
-    return logger2.error(message, data);
-  }
-};
 
 // src/features/analysis/scm/github/consts.ts
 var POST_COMMENT_PATH = "POST /repos/{owner}/{repo}/pulls/{pull_number}/comments";
@@ -8009,35 +7984,6 @@ var GET_A_REPOSITORY_PUBLIC_KEY = "GET /repos/{owner}/{repo}/actions/secrets/pub
 var GET_USER = "GET /user";
 var GET_USER_REPOS = "GET /user/repos";
 var GET_REPO_BRANCHES = "GET /repos/{owner}/{repo}/branches";
-var GET_BLAME_DOCUMENT = `
-      query GetBlame(
-        $owner: String!
-        $repo: String!
-        $ref: String!
-        $path: String!
-      ) {
-        repository(name: $repo, owner: $owner) {
-          # branch name
-          object(expression: $ref) {
-            # cast Target to a Commit
-            ... on Commit {
-              # full repo-relative path to blame file
-              blame(path: $path) {
-                ranges {
-                  commit {
-                    oid
-                  }
-                  startingLine
-                  endingLine
-                  age
-                }
-              }
-            }
-
-          }
-        }
-      }
-    `;
 var GITHUB_GRAPHQL_FRAGMENTS = {
   /**
    * Fragment for fetching PR additions/deletions.
@@ -8061,30 +8007,6 @@ var GITHUB_GRAPHQL_FRAGMENTS = {
         body
       }
     }
-  `,
-  /**
-   * Fragment for fetching blame data.
-   * Use with object(expression: $ref) on Commit type.
-   * Note: $path placeholder must be replaced with actual file path.
-   */
-  BLAME_RANGES: `
-    blame(path: "$path") {
-      ranges {
-        startingLine
-        endingLine
-        commit {
-          oid
-        }
-      }
-    }
-  `,
-  /**
-   * Fragment for fetching commit timestamp.
-   * Use with object(oid: $sha) on Commit type.
-   */
-  COMMIT_TIMESTAMP: `
-    oid
-    committedDate
   `
 };
 var GET_PR_METRICS_QUERY = `
@@ -8296,112 +8218,6 @@ async function githubValidateParams(url, accessToken) {
 
 // src/features/analysis/scm/github/github.ts
 var MAX_GH_PR_BODY_LENGTH = 65536;
-var BLAME_LARGE_FILE_THRESHOLD_BYTES = 1e6;
-var BLAME_THRESHOLD_REDUCTION_BYTES = 1e5;
-var BLAME_MIN_THRESHOLD_BYTES = 1e5;
-var GRAPHQL_INPUT_PATTERNS = {
-  // File paths: most printable ASCII chars, unicode letters/numbers
-  // Allows: letters, numbers, spaces, common punctuation, path separators
-  // Disallows: control characters, null bytes
-  path: /^[\p{L}\p{N}\p{Zs}\-._/@+#~%()[\]{}=!,;'&]+$/u,
-  // Git refs: branch/tag names follow git-check-ref-format rules
-  // Allows: letters, numbers, slashes, dots, hyphens, underscores
-  // Can also be "ref:path" format for expressions
-  ref: /^[\p{L}\p{N}\-._/:@]+$/u,
-  // Git SHAs: strictly hexadecimal (short or full)
-  sha: /^[0-9a-fA-F]+$/
-};
-function validateGraphQLInput(value, type2) {
-  const pattern = GRAPHQL_INPUT_PATTERNS[type2];
-  if (!pattern.test(value)) {
-    void contextLogger.info(
-      "[GraphQL] Input contains unexpected characters, proceeding with escaping",
-      {
-        type: type2,
-        valueLength: value.length,
-        // Log first 100 chars to help debug without exposing full value
-        valueSample: value.slice(0, 100)
-      }
-    );
-    return false;
-  }
-  return true;
-}
-function escapeGraphQLString(value) {
-  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\f/g, "\\f").replace(/[\b]/g, "\\b");
-}
-function safeGraphQLString(value, type2) {
-  validateGraphQLInput(value, type2);
-  return escapeGraphQLString(value);
-}
-function extractBlameRanges(data) {
-  const fileData = data;
-  if (fileData.blame?.ranges) {
-    return fileData.blame.ranges.map((range) => ({
-      startingLine: range.startingLine,
-      endingLine: range.endingLine,
-      commitSha: range.commit.oid
-    }));
-  }
-  return void 0;
-}
-function buildBlameFragment(ref) {
-  const escapedRef = safeGraphQLString(ref, "ref");
-  return (path25, index) => {
-    const escapedPath = safeGraphQLString(path25, "path");
-    return `
-    file${index}: object(expression: "${escapedRef}") {
-      ... on Commit {
-        ${GITHUB_GRAPHQL_FRAGMENTS.BLAME_RANGES.replace("$path", escapedPath)}
-      }
-    }`;
-  };
-}
-function createBatchesByTotalSize(files, threshold) {
-  const batches = [];
-  let currentBatch = [];
-  let currentBatchSize = 0;
-  for (const file of files) {
-    if (currentBatchSize + file.size > threshold && currentBatch.length > 0) {
-      batches.push(currentBatch);
-      currentBatch = [];
-      currentBatchSize = 0;
-    }
-    currentBatch.push(file);
-    currentBatchSize += file.size;
-  }
-  if (currentBatch.length > 0) {
-    batches.push(currentBatch);
-  }
-  return batches;
-}
-async function fetchBlameForBatch(octokit, owner, repo, ref, files) {
-  if (files.length === 0) {
-    return /* @__PURE__ */ new Map();
-  }
-  return executeBatchGraphQL(octokit, owner, repo, {
-    items: files.map((f) => f.path),
-    aliasPrefix: "file",
-    buildFragment: buildBlameFragment(ref),
-    extractResult: extractBlameRanges
-  });
-}
-async function processBlameAttempt(params) {
-  const { octokit, owner, repo, ref, batches, concurrency } = params;
-  const result = /* @__PURE__ */ new Map();
-  const limit = pLimit(concurrency);
-  const batchResults = await Promise.all(
-    batches.map(
-      (batch) => limit(() => fetchBlameForBatch(octokit, owner, repo, ref, batch))
-    )
-  );
-  for (const batchResult of batchResults) {
-    for (const [path25, blameData] of batchResult) {
-      result.set(path25, blameData);
-    }
-  }
-  return result;
-}
 async function executeBatchGraphQL(octokit, owner, repo, config2) {
   const { items, aliasPrefix, buildFragment, extractResult } = config2;
   if (items.length === 0) {
@@ -8716,29 +8532,6 @@ function getGithubSdk(params = {}) {
         sha: res.data.sha
       };
     },
-    async getGithubBlameRanges(params2) {
-      const { ref, gitHubUrl, path: path25 } = params2;
-      const { owner, repo } = parseGithubOwnerAndRepo(gitHubUrl);
-      const res = await octokit.graphql(
-        GET_BLAME_DOCUMENT,
-        {
-          owner,
-          repo,
-          path: path25,
-          ref
-        }
-      );
-      if (!res?.repository?.object?.blame?.ranges) {
-        return [];
-      }
-      return res.repository.object.blame.ranges.map(
-        (range) => ({
-          startingLine: range.startingLine,
-          endingLine: range.endingLine,
-          commitSha: range.commit.oid
-        })
-      );
-    },
     /**
      * Fetches commits for multiple PRs in a single GraphQL request.
      * This is much more efficient than making N separate REST API calls.
@@ -9022,232 +8815,6 @@ function getGithubSdk(params = {}) {
         }
       });
     },
-    /**
-     * Batch fetch blob sizes for multiple files via GraphQL.
-     * Used to determine which files are too large to batch in blame queries.
-     */
-    async getBlobSizesBatch(params2) {
-      return executeBatchGraphQL(octokit, params2.owner, params2.repo, {
-        items: params2.blobShas,
-        aliasPrefix: "blob",
-        buildFragment: (sha, index) => {
-          const escapedSha = safeGraphQLString(sha, "sha");
-          return `
-          blob${index}: object(oid: "${escapedSha}") {
-            ... on Blob {
-              byteSize
-            }
-          }`;
-        },
-        extractResult: (data) => {
-          const blobData = data;
-          if (blobData.byteSize !== void 0) {
-            return blobData.byteSize;
-          }
-          return void 0;
-        }
-      });
-    },
-    /**
-     * Batch fetch blame data for multiple files via GraphQL.
-     * Uses GITHUB_GRAPHQL_FRAGMENTS.BLAME_RANGES for the field selection.
-     *
-     * Optimized to handle large files with retry logic:
-     * - Files above threshold are processed individually with rate limiting
-     * - On failure, retries with reduced threshold (-100KB) and concurrency (-1)
-     * - Continues until success or threshold < 100KB
-     *
-     * @param params.files - Array of files with path and blobSha for size lookup
-     * @param params.concurrency - Max concurrent requests for large files (default: 2)
-     */
-    async getBlameBatch(params2) {
-      const {
-        owner,
-        repo,
-        ref,
-        files,
-        concurrency: initialConcurrency = 2
-      } = params2;
-      if (files.length === 0) {
-        return /* @__PURE__ */ new Map();
-      }
-      const filesWithSizes = await this.fetchFilesWithSizes(owner, repo, files);
-      return this.executeBlameWithRetries({
-        owner,
-        repo,
-        ref,
-        filesWithSizes,
-        initialConcurrency
-      });
-    },
-    /**
-     * Fetches blob sizes and creates a list of files with their sizes.
-     */
-    async fetchFilesWithSizes(owner, repo, files) {
-      const blobShas = files.map((f) => f.blobSha);
-      const blobSizes = await this.getBlobSizesBatch({ owner, repo, blobShas });
-      return files.map((file) => ({
-        ...file,
-        size: blobSizes.get(file.blobSha) ?? 0
-      }));
-    },
-    /**
-     * Executes blame fetching with retry logic on failure.
-     * Reduces threshold and concurrency on each retry attempt.
-     */
-    async executeBlameWithRetries(params2) {
-      const { owner, repo, ref, filesWithSizes, initialConcurrency } = params2;
-      let threshold = BLAME_LARGE_FILE_THRESHOLD_BYTES;
-      let concurrency = initialConcurrency;
-      let attempt = 1;
-      let lastError = null;
-      while (threshold >= BLAME_MIN_THRESHOLD_BYTES) {
-        const batches = createBatchesByTotalSize(filesWithSizes, threshold);
-        this.logBlameAttemptStart(
-          attempt,
-          threshold,
-          concurrency,
-          filesWithSizes.length,
-          batches.length,
-          owner,
-          repo,
-          ref
-        );
-        try {
-          const result = await processBlameAttempt({
-            octokit,
-            owner,
-            repo,
-            ref,
-            batches,
-            concurrency
-          });
-          this.logBlameAttemptSuccess(attempt, result.size, owner, repo);
-          return result;
-        } catch (error) {
-          lastError = error instanceof Error ? error : new Error(String(error));
-          this.logBlameAttemptFailure(
-            attempt,
-            threshold,
-            concurrency,
-            lastError.message,
-            owner,
-            repo
-          );
-          threshold -= BLAME_THRESHOLD_REDUCTION_BYTES;
-          concurrency = Math.max(1, concurrency - 1);
-          attempt++;
-        }
-      }
-      void contextLogger.error("[getBlameBatch] Exhausted all retries", {
-        attempts: attempt - 1,
-        repo: `${owner}/${repo}`,
-        ref,
-        error: lastError?.message || "unknown"
-      });
-      throw lastError || new Error("getBlameBatch failed after all retries");
-    },
-    /**
-     * Logs the start of a blame batch attempt.
-     */
-    logBlameAttemptStart(attempt, threshold, concurrency, totalFiles, batchCount, owner, repo, ref) {
-      void contextLogger.debug("[getBlameBatch] Processing attempt", {
-        attempt,
-        threshold,
-        concurrency,
-        totalFiles,
-        batchCount,
-        repo: `${owner}/${repo}`,
-        ref
-      });
-    },
-    /**
-     * Logs a successful blame batch attempt.
-     */
-    logBlameAttemptSuccess(attempt, filesProcessed, owner, repo) {
-      void contextLogger.debug("[getBlameBatch] Successfully processed batch", {
-        attempt,
-        filesProcessed,
-        repo: `${owner}/${repo}`
-      });
-    },
-    /**
-     * Logs a failed blame batch attempt.
-     */
-    logBlameAttemptFailure(attempt, threshold, concurrency, errorMessage, owner, repo) {
-      void contextLogger.debug(
-        "[getBlameBatch] Attempt failed, retrying with reduced threshold",
-        {
-          attempt,
-          threshold,
-          concurrency,
-          error: errorMessage,
-          repo: `${owner}/${repo}`
-        }
-      );
-    },
-    /**
-     * Batch fetch blame data for multiple files via GraphQL (legacy interface).
-     * This is a convenience wrapper that accepts file paths without blob SHAs.
-     * Note: This does NOT perform size-based optimization. Use getBlameBatch with
-     * files array including blobSha for optimized large file handling.
-     */
-    async getBlameBatchByPaths(params2) {
-      const escapedRef = safeGraphQLString(params2.ref, "ref");
-      return executeBatchGraphQL(octokit, params2.owner, params2.repo, {
-        items: params2.filePaths,
-        aliasPrefix: "file",
-        buildFragment: (path25, index) => {
-          const escapedPath = safeGraphQLString(path25, "path");
-          return `
-          file${index}: object(expression: "${escapedRef}") {
-            ... on Commit {
-              ${GITHUB_GRAPHQL_FRAGMENTS.BLAME_RANGES.replace("$path", escapedPath)}
-            }
-          }`;
-        },
-        extractResult: (data) => {
-          const fileData = data;
-          if (fileData.blame?.ranges) {
-            return fileData.blame.ranges.map((range) => ({
-              startingLine: range.startingLine,
-              endingLine: range.endingLine,
-              commitSha: range.commit.oid
-            }));
-          }
-          return void 0;
-        }
-      });
-    },
-    /**
-     * Batch fetch commit timestamps for multiple commits via GraphQL.
-     * Uses GITHUB_GRAPHQL_FRAGMENTS.COMMIT_TIMESTAMP for the field selection.
-     */
-    async getCommitsBatch(params2) {
-      return executeBatchGraphQL(octokit, params2.owner, params2.repo, {
-        items: params2.commitShas,
-        aliasPrefix: "commit",
-        buildFragment: (sha, index) => {
-          const escapedSha = safeGraphQLString(sha, "sha");
-          return `
-          commit${index}: object(oid: "${escapedSha}") {
-            ... on Commit {
-              ${GITHUB_GRAPHQL_FRAGMENTS.COMMIT_TIMESTAMP}
-            }
-          }`;
-        },
-        extractResult: (data) => {
-          const commitData = data;
-          if (commitData.oid && commitData.committedDate) {
-            return {
-              sha: commitData.oid,
-              timestamp: new Date(commitData.committedDate)
-            };
-          }
-          return void 0;
-        }
-      });
-    },
     async getPRMetricsGraphQL(params2) {
       const res = await octokit.graphql(
         GET_PR_METRICS_QUERY,
@@ -9452,10 +9019,26 @@ var GithubSCMLib = class _GithubSCMLib extends SCMLib {
   async getRecentCommits(since) {
     this._validateAccessTokenAndUrl();
     const { owner, repo } = parseGithubOwnerAndRepo(this.url);
-    return await this.githubSdk.getRecentCommits({ owner, repo, since });
-  }
+    const result = await this.githubSdk.getRecentCommits({ owner, repo, since });
+    return {
+      data: result.data.map((c) => ({
+        sha: c.sha,
+        commit: {
+          committer: c.commit.committer ? { date: c.commit.committer.date } : void 0,
+          author: c.commit.author ? { email: c.commit.author.email, name: c.commit.author.name } : void 0,
+          message: c.commit.message
+        },
+        parents: c.parents?.map((p) => ({ sha: p.sha }))
+      }))
+    };
+  }
   async getRateLimitStatus() {
-    return await this.githubSdk.getRateLimitStatus();
+    const result = await this.githubSdk.getRateLimitStatus();
+    return {
+      remaining: result.remaining,
+      reset: result.reset,
+      limit: result.limit
+    };
   }
   get scmLibType() {
     return "GITHUB" /* GITHUB */;
@@ -9513,14 +9096,6 @@ var GithubSCMLib = class _GithubSCMLib extends SCMLib {
       markdownComment: comment
     });
   }
-  async getRepoBlameRanges(ref, path25) {
-    this._validateUrl();
-    return await this.githubSdk.getGithubBlameRanges({
-      ref,
-      path: path25,
-      gitHubUrl: this.url
-    });
-  }
   async getReferenceData(ref) {
     this._validateUrl();
     return await this.githubSdk.getGithubReferenceData({
@@ -9610,37 +9185,6 @@ var GithubSCMLib = class _GithubSCMLib extends SCMLib {
       commitSha
     });
     const commitTimestamp = commit.commit.committer?.date ? new Date(commit.commit.committer.date) : new Date(commit.commit.author?.date || Date.now());
-    let parentCommits;
-    if (commit.parents && commit.parents.length > 0) {
-      if (options?.parentCommitTimestamps) {
-        parentCommits = commit.parents.map((p) => options.parentCommitTimestamps.get(p.sha)).filter((p) => p !== void 0);
-      } else {
-        try {
-          parentCommits = await Promise.all(
-            commit.parents.map(async (parent) => {
-              const parentCommit = await this.githubSdk.getCommit({
-                owner,
-                repo,
-                commitSha: parent.sha
-              });
-              const parentTimestamp = parentCommit.data.committer?.date ? new Date(parentCommit.data.committer.date) : new Date(Date.now());
-              return {
-                sha: parent.sha,
-                timestamp: parentTimestamp
-              };
-            })
-          );
-        } catch (error) {
-          console.error("Failed to fetch parent commit timestamps", {
-            error,
-            commitSha,
-            owner,
-            repo
-          });
-          parentCommits = void 0;
-        }
-      }
-    }
     let repositoryCreatedAt = options?.repositoryCreatedAt;
     if (repositoryCreatedAt === void 0) {
       try {
@@ -9662,7 +9206,6 @@ var GithubSCMLib = class _GithubSCMLib extends SCMLib {
       authorName: commit.commit.author?.name,
       authorEmail: commit.commit.author?.email,
       message: commit.commit.message,
-      parentCommits,
       repositoryCreatedAt
     };
   }
@@ -9670,46 +9213,31 @@ var GithubSCMLib = class _GithubSCMLib extends SCMLib {
     this._validateAccessTokenAndUrl();
     const { owner, repo } = parseGithubOwnerAndRepo(this.url);
     const prNumber = Number(submitRequestId);
-    const [prRes, commitsRes, filesRes, repoData] = await Promise.all([
+    const [prRes, commitsRes, repoData, prDiff] = await Promise.all([
       this.githubSdk.getPr({ owner, repo, pull_number: prNumber }),
       this.githubSdk.getPrCommits({ owner, repo, pull_number: prNumber }),
-      this.githubSdk.listPRFiles({ owner, repo, pull_number: prNumber }),
-      this.githubSdk.getRepository({ owner, repo })
+      this.githubSdk.getRepository({ owner, repo }),
+      this.getPrDiff({ pull_number: prNumber })
     ]);
     const pr = prRes.data;
     const repositoryCreatedAt = repoData.data.created_at ? new Date(repoData.data.created_at) : void 0;
-    const allParentShas = /* @__PURE__ */ new Set();
-    for (const commit of commitsRes.data) {
-      if (commit.parents) {
-        for (const parent of commit.parents) {
-          allParentShas.add(parent.sha);
-        }
-      }
-    }
-    const [parentCommitTimestamps, prDiff] = await Promise.all([
-      this.githubSdk.getCommitsBatch({
-        owner,
-        repo,
-        commitShas: Array.from(allParentShas)
-      }),
-      this.getPrDiff({ pull_number: prNumber })
-    ]);
-    const limit = pLimit2(GITHUB_API_CONCURRENCY);
+    const limit = pLimit(GITHUB_API_CONCURRENCY);
     const commits = await Promise.all(
       commitsRes.data.map(
         (commit) => limit(
           () => this.getCommitDiff(commit.sha, {
-            repositoryCreatedAt,
-            parentCommitTimestamps
+            repositoryCreatedAt
           })
         )
       )
     );
-    const diffLines = filesRes ? await this._attributeLinesViaBlame({
-      headSha: pr.head.sha,
-      changedFiles: filesRes.data,
-      prCommits: commits
-    }) : [];
+    const addedLinesByFile = parseAddedLinesByFile(prDiff);
+    const diffLines = [];
+    for (const [file, lines] of addedLinesByFile) {
+      for (const line of lines) {
+        diffLines.push({ file, line });
+      }
+    }
     return {
       diff: prDiff,
       createdAt: new Date(pr.created_at),
@@ -9726,47 +9254,6 @@ var GithubSCMLib = class _GithubSCMLib extends SCMLib {
       diffLines
     };
   }
-  async getSubmitRequests(repoUrl) {
-    this._validateAccessToken();
-    const { owner, repo } = parseGithubOwnerAndRepo(repoUrl);
-    const pullsRes = await this.githubSdk.getRepoPullRequests({ owner, repo });
-    const prNumbers = pullsRes.data.map((pr) => pr.number);
-    const [additionsDeletionsMap, commentsMap] = await Promise.all([
-      this.githubSdk.getPrAdditionsDeletionsBatch({ owner, repo, prNumbers }),
-      this.githubSdk.getPrCommentsBatch({ owner, repo, prNumbers })
-    ]);
-    const submitRequests = pullsRes.data.map((pr) => {
-      let status = "open";
-      if (pr.state === "closed") {
-        status = pr.merged_at ? "merged" : "closed";
-      } else if (pr.draft) {
-        status = "draft";
-      }
-      const changedLinesData = additionsDeletionsMap.get(pr.number);
-      const changedLines = changedLinesData ? {
-        added: changedLinesData.additions,
-        removed: changedLinesData.deletions
-      } : { added: 0, removed: 0 };
-      const comments = commentsMap.get(pr.number) || [];
-      const tickets = _GithubSCMLib.extractLinearTicketsFromComments(comments);
-      return {
-        submitRequestId: String(pr.number),
-        submitRequestNumber: pr.number,
-        title: pr.title,
-        status,
-        sourceBranch: pr.head.ref,
-        targetBranch: pr.base.ref,
-        authorName: pr.user?.name || pr.user?.login,
-        authorEmail: pr.user?.email || void 0,
-        createdAt: new Date(pr.created_at),
-        updatedAt: new Date(pr.updated_at),
-        description: pr.body || void 0,
-        tickets,
-        changedLines
-      };
-    });
-    return submitRequests;
-  }
   /**
    * Override searchSubmitRequests to use GitHub's Search API for efficient pagination.
    * This is much faster than fetching all PRs and filtering in-memory.
@@ -9985,146 +9472,26 @@ var GithubSCMLib = class _GithubSCMLib extends SCMLib {
     };
   }
   /**
-   * Parse a Linear ticket from URL and name
-   * Returns null if invalid or missing data
+   * Extract Linear ticket links from pre-fetched comments (pure function, no API calls)
+   * Instance method that overrides base class - can also be called statically for backwards compatibility.
    */
-  static _parseLinearTicket(url, name) {
-    if (!name || !url) {
-      return null;
-    }
-    const urlParts = url.split("/");
-    const titleSlug = urlParts[urlParts.length - 1] || "";
-    const title = titleSlug.replace(/-/g, " ");
-    return { name, title, url };
+  extractLinearTicketsFromComments(comments) {
+    return _GithubSCMLib._extractLinearTicketsFromCommentsImpl(comments);
   }
   /**
-   * Extract Linear ticket links from pre-fetched comments (pure function, no API calls)
-   * Public static method so it can be reused by backend services.
+   * Static implementation for backwards compatibility and reuse.
+   * Called by both the instance method and direct static calls.
    */
-  static extractLinearTicketsFromComments(comments) {
+  static _extractLinearTicketsFromCommentsImpl(comments) {
     const tickets = [];
     const seen = /* @__PURE__ */ new Set();
     for (const comment of comments) {
       if (comment.author?.login === "linear[bot]" || comment.author?.type === "Bot") {
-        const body = comment.body || "";
-        const htmlPattern = /<a href="(https:\/\/linear\.app\/[^"]+)">([A-Z]+-\d+)<\/a>/g;
-        let match;
-        while ((match = htmlPattern.exec(body)) !== null) {
-          const ticket = _GithubSCMLib._parseLinearTicket(match[1], match[2]);
-          if (ticket && !seen.has(`${ticket.name}|${ticket.url}`)) {
-            seen.add(`${ticket.name}|${ticket.url}`);
-            tickets.push(ticket);
-          }
-        }
-        const markdownPattern = /\[([A-Z]+-\d+)\]\((https:\/\/linear\.app\/[^)]+)\)/g;
-        while ((match = markdownPattern.exec(body)) !== null) {
-          const ticket = _GithubSCMLib._parseLinearTicket(match[2], match[1]);
-          if (ticket && !seen.has(`${ticket.name}|${ticket.url}`)) {
-            seen.add(`${ticket.name}|${ticket.url}`);
-            tickets.push(ticket);
-          }
-        }
+        tickets.push(...extractLinearTicketsFromBody(comment.body || "", seen));
       }
     }
     return tickets;
   }
-  /**
-   * Optimized helper to parse added line numbers from a unified diff patch
-   * Single-pass parsing for minimal CPU usage
-   */
-  _parseAddedLinesFromPatch(patch) {
-    const addedLines = [];
-    const lines = patch.split("\n");
-    let currentLineNumber = 0;
-    for (const line of lines) {
-      if (line.startsWith("@@")) {
-        const match = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)/);
-        if (match?.[1]) {
-          currentLineNumber = parseInt(match[1], 10);
-        }
-        continue;
-      }
-      if (line.startsWith("+") && !line.startsWith("+++")) {
-        addedLines.push(currentLineNumber);
-        currentLineNumber++;
-      } else if (!line.startsWith("-")) {
-        currentLineNumber++;
-      }
-    }
-    return addedLines;
-  }
-  /**
-   * Process blame data for a single file to attribute lines to commits
-   * Uses pre-fetched blame data instead of making API calls
-   */
-  _processFileBlameSafe(file, blameData, prCommitShas) {
-    const addedLines = this._parseAddedLinesFromPatch(file.patch);
-    const addedLinesSet = new Set(addedLines);
-    const fileAttributions = [];
-    for (const blameRange of blameData) {
-      if (!prCommitShas.has(blameRange.commitSha)) {
-        continue;
-      }
-      for (let lineNum = blameRange.startingLine; lineNum <= blameRange.endingLine; lineNum++) {
-        if (addedLinesSet.has(lineNum)) {
-          fileAttributions.push({
-            file: file.filename,
-            line: lineNum,
-            commitSha: blameRange.commitSha
-          });
-        }
-      }
-    }
-    return fileAttributions;
-  }
-  /**
-   * Optimized helper to attribute PR lines to commits using blame API
-   * Batch blame queries for minimal API call time (1 call instead of M calls)
-   *
-   * Uses size-based batching to handle large files:
-   * - Files > 1MB are processed individually with rate limiting
-   * - Smaller files are batched together in a single request
-   * This prevents GitHub API timeouts (~10s) on large generated files.
-   */
-  async _attributeLinesViaBlame(params) {
-    const { headSha, changedFiles, prCommits } = params;
-    const prCommitShas = new Set(prCommits.map((c) => c.commitSha));
-    const filesWithAdditions = changedFiles.filter((file) => {
-      if (!file.patch || file.patch.trim().length === 0) {
-        return false;
-      }
-      if (!file.sha) {
-        return false;
-      }
-      return true;
-    });
-    if (filesWithAdditions.length === 0) {
-      return [];
-    }
-    const { owner, repo } = parseGithubOwnerAndRepo(this.url);
-    const blameMap = await this.githubSdk.getBlameBatch({
-      owner,
-      repo,
-      ref: headSha,
-      // Use commit SHA directly from PR.head.sha
-      files: filesWithAdditions.map((f) => ({
-        path: f.filename,
-        blobSha: f.sha
-      })),
-      concurrency: GITHUB_API_CONCURRENCY
-    });
-    const allAttributions = [];
-    for (const file of filesWithAdditions) {
-      const blameData = blameMap.get(file.filename) || [];
-      const fileAttributions = this._processFileBlameSafe(
-        file,
-        blameData,
-        prCommitShas
-      );
-      allAttributions.push(...fileAttributions);
-    }
-    return allAttributions;
-  }
 };
 
 // src/features/analysis/scm/gitlab/gitlab.ts
@@ -10137,11 +9504,72 @@ import {
   Gitlab
 } from "@gitbeaker/rest";
 import Debug3 from "debug";
+import pLimit2 from "p-limit";
 import {
   Agent,
   fetch as undiciFetch,
   ProxyAgent as ProxyAgent2
 } from "undici";
+
+// src/utils/contextLogger.ts
+import debugModule from "debug";
+var debug3 = debugModule("mobb:shared");
+var _contextLogger = null;
+var createContextLogger = async () => {
+  if (_contextLogger) return _contextLogger;
+  try {
+    let logger2;
+    try {
+      let module;
+      try {
+        const buildPath = "../../../../../tscommon/backend/build/src/utils/logger";
+        module = await import(buildPath);
+      } catch (e) {
+        const sourcePath = "../../../../../tscommon/backend/src/utils/logger";
+        module = await import(sourcePath);
+      }
+      logger2 = module.logger;
+    } catch {
+    }
+    if (logger2) {
+      _contextLogger = {
+        info: (message, data) => data ? logger2.info(data, message) : logger2.info(message),
+        warn: (message, data) => data ? logger2.warn(data, message) : logger2.warn(message),
+        debug: (message, data) => data ? logger2.debug(data, message) : logger2.debug(message),
+        error: (message, data) => data ? logger2.error(data, message) : logger2.error(message)
+      };
+      return _contextLogger;
+    }
+  } catch {
+  }
+  _contextLogger = {
+    info: (message, data) => debug3(message, data),
+    warn: (message, data) => debug3(message, data),
+    debug: (message, data) => debug3(message, data),
+    error: (message, data) => debug3(message, data)
+  };
+  return _contextLogger;
+};
+var contextLogger = {
+  info: async (message, data) => {
+    const logger2 = await createContextLogger();
+    return logger2.info(message, data);
+  },
+  debug: async (message, data) => {
+    const logger2 = await createContextLogger();
+    return logger2.debug(message, data);
+  },
+  warn: async (message, data) => {
+    const logger2 = await createContextLogger();
+    return logger2.warn(message, data);
+  },
+  error: async (message, data) => {
+    const logger2 = await createContextLogger();
+    return logger2.error(message, data);
+  }
+};
+
+// src/features/analysis/scm/gitlab/gitlab.ts
 init_env();
 
 // src/features/analysis/scm/gitlab/types.ts
@@ -10158,6 +9586,14 @@ function removeTrailingSlash2(str) {
   return str.trim().replace(/\/+$/, "");
 }
 var MAX_GITLAB_PR_BODY_LENGTH = 1048576;
+function buildUnifiedDiff(diffs) {
+  return diffs.filter((d) => d.diff).map((d) => {
+    const oldPath = d.old_path || d.new_path || "";
+    const newPath = d.new_path || d.old_path || "";
+    return `diff --git a/${oldPath} b/${newPath}
+${d.diff}`;
+  }).join("\n");
+}
 function getRandomGitlabCloudAnonToken() {
   if (!GITLAB_API_TOKEN || typeof GITLAB_API_TOKEN !== "string") {
     return void 0;
@@ -10211,7 +9647,10 @@ async function gitlabValidateParams({
     if (code === 404 || description.includes("404") || description.includes("Not Found")) {
       throw new InvalidRepoUrlError(`invalid gitlab repo URL: ${url}`);
     }
-    console.log("gitlabValidateParams error", e);
+    contextLogger.warn("[gitlabValidateParams] Error validating params", {
+      url,
+      error: e
+    });
     throw new InvalidRepoUrlError(
       `cannot access gitlab repo URL: ${url} with the provided access token`
     );
@@ -10240,6 +9679,13 @@ async function getGitlabIsUserCollaborator({
     ];
     return accessLevelWithWriteAccess.includes(groupAccess) || accessLevelWithWriteAccess.includes(projectAccess);
   } catch (e) {
+    contextLogger.warn(
+      "[getGitlabIsUserCollaborator] Error checking collaborator status",
+      {
+        error: e instanceof Error ? e.message : String(e),
+        repoUrl
+      }
+    );
     return false;
   }
 }
@@ -10286,6 +9732,14 @@ async function getGitlabIsRemoteBranch({
     const res = await api2.Branches.show(projectPath, branch);
     return res.name === branch;
   } catch (e) {
+    contextLogger.warn(
+      "[getGitlabIsRemoteBranch] Error checking remote branch",
+      {
+        error: e instanceof Error ? e.message : String(e),
+        repoUrl,
+        branch
+      }
+    );
     return false;
   }
 }
@@ -10318,49 +9772,257 @@ async function getGitlabRepoList(url, accessToken) {
     })
   );
 }
-async function getGitlabBranchList({
-  accessToken,
-  repoUrl
+async function getGitlabBranchList({
+  accessToken,
+  repoUrl
+}) {
+  const { projectPath } = parseGitlabOwnerAndRepo(repoUrl);
+  const api2 = getGitBeaker({ url: repoUrl, gitlabAuthToken: accessToken });
+  try {
+    const res = await api2.Branches.all(projectPath, {
+      //keyset API pagination is not supported by GL for the branch list (at least not the on-prem version)
+      //so for now we stick with the default pagination and just return the first page and limit the results to 1000 entries.
+      //This is a temporary solution until we implement list branches with name search.
+      perPage: MAX_BRANCHES_FETCH,
+      page: 1
+    });
+    res.sort((a, b) => {
+      if (!a.commit?.committed_date || !b.commit?.committed_date) {
+        return 0;
+      }
+      return new Date(b.commit?.committed_date).getTime() - new Date(a.commit?.committed_date).getTime();
+    });
+    return res.map((branch) => branch.name).slice(0, MAX_BRANCHES_FETCH);
+  } catch (e) {
+    contextLogger.warn("[getGitlabBranchList] Error fetching branch list", {
+      error: e instanceof Error ? e.message : String(e),
+      repoUrl
+    });
+    return [];
+  }
+}
+async function createMergeRequest(options) {
+  const { projectPath } = parseGitlabOwnerAndRepo(options.repoUrl);
+  const api2 = getGitBeaker({
+    url: options.repoUrl,
+    gitlabAuthToken: options.accessToken
+  });
+  const res = await api2.MergeRequests.create(
+    projectPath,
+    options.sourceBranchName,
+    options.targetBranchName,
+    options.title,
+    {
+      description: safeBody(options.body, MAX_GITLAB_PR_BODY_LENGTH)
+    }
+  );
+  return res.iid;
+}
+async function getGitlabMergeRequest({
+  url,
+  prNumber,
+  accessToken
+}) {
+  const { projectPath } = parseGitlabOwnerAndRepo(url);
+  const api2 = getGitBeaker({
+    url,
+    gitlabAuthToken: accessToken
+  });
+  return await api2.MergeRequests.show(projectPath, prNumber);
+}
+async function searchGitlabMergeRequests({
+  repoUrl,
+  accessToken,
+  state,
+  updatedAfter,
+  orderBy = "updated_at",
+  sort = "desc",
+  perPage = GITLAB_PER_PAGE,
+  page = 1
+}) {
+  const { projectPath } = parseGitlabOwnerAndRepo(repoUrl);
+  debug4(
+    "[searchGitlabMergeRequests] Fetching MRs for %s (page=%d, perPage=%d)",
+    projectPath,
+    page,
+    perPage
+  );
+  const api2 = getGitBeaker({
+    url: repoUrl,
+    gitlabAuthToken: accessToken
+  });
+  const mergeRequests = await api2.MergeRequests.all({
+    projectId: projectPath,
+    state: state === "all" ? void 0 : state,
+    updatedAfter: updatedAfter?.toISOString(),
+    orderBy,
+    sort,
+    perPage,
+    page
+  });
+  const items = mergeRequests.map((mr) => ({
+    iid: mr.iid,
+    title: mr.title,
+    state: mr.state,
+    sourceBranch: mr.source_branch,
+    targetBranch: mr.target_branch,
+    authorUsername: mr.author?.username,
+    createdAt: mr.created_at,
+    updatedAt: mr.updated_at,
+    description: mr.description
+  }));
+  debug4(
+    "[searchGitlabMergeRequests] Found %d MRs on page %d",
+    items.length,
+    page
+  );
+  return {
+    items,
+    hasMore: mergeRequests.length === perPage
+  };
+}
+var GITLAB_API_CONCURRENCY = 5;
+async function getGitlabMrCommitsBatch({
+  repoUrl,
+  accessToken,
+  mrNumbers
+}) {
+  if (mrNumbers.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const { projectPath } = parseGitlabOwnerAndRepo(repoUrl);
+  const api2 = getGitBeaker({
+    url: repoUrl,
+    gitlabAuthToken: accessToken
+  });
+  const limit = pLimit2(GITLAB_API_CONCURRENCY);
+  const results = await Promise.all(
+    mrNumbers.map(
+      (mrNumber) => limit(async () => {
+        try {
+          const commits = await api2.MergeRequests.allCommits(
+            projectPath,
+            mrNumber
+          );
+          return [mrNumber, commits.map((c) => c.id)];
+        } catch (error) {
+          contextLogger.warn(
+            "[getGitlabMrCommitsBatch] Failed to fetch commits for MR",
+            {
+              error: error instanceof Error ? error.message : String(error),
+              mrNumber,
+              repoUrl
+            }
+          );
+          return [mrNumber, []];
+        }
+      })
+    )
+  );
+  return new Map(results);
+}
+async function getGitlabMrDataBatch({
+  repoUrl,
+  accessToken,
+  mrNumbers
+}) {
+  if (mrNumbers.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const { projectPath } = parseGitlabOwnerAndRepo(repoUrl);
+  const api2 = getGitBeaker({
+    url: repoUrl,
+    gitlabAuthToken: accessToken
+  });
+  const limit = pLimit2(GITLAB_API_CONCURRENCY);
+  const results = await Promise.all(
+    mrNumbers.map(
+      (mrNumber) => limit(async () => {
+        try {
+          const [diffs, notes] = await Promise.all([
+            api2.MergeRequests.allDiffs(projectPath, mrNumber),
+            api2.MergeRequestNotes.all(projectPath, mrNumber)
+          ]);
+          let additions = 0;
+          let deletions = 0;
+          for (const diff of diffs) {
+            if (diff.diff) {
+              for (const line of diff.diff.split("\n")) {
+                if (line.startsWith("+") && !line.startsWith("+++")) {
+                  additions++;
+                } else if (line.startsWith("-") && !line.startsWith("---")) {
+                  deletions++;
+                }
+              }
+            }
+          }
+          const comments = notes.map((note) => ({
+            author: note.author ? {
+              login: note.author.username,
+              type: note.author.username.endsWith("[bot]") || note.author.username.toLowerCase() === "linear" ? "Bot" : "User"
+            } : null,
+            body: note.body
+          }));
+          return [
+            mrNumber,
+            { changedLines: { additions, deletions }, comments }
+          ];
+        } catch (error) {
+          contextLogger.warn(
+            "[getGitlabMrDataBatch] Failed to fetch data for MR",
+            {
+              error: error instanceof Error ? error.message : String(error),
+              mrNumber,
+              repoUrl
+            }
+          );
+          return [
+            mrNumber,
+            {
+              changedLines: { additions: 0, deletions: 0 },
+              comments: []
+            }
+          ];
+        }
+      })
+    )
+  );
+  return new Map(results);
+}
+async function getGitlabMergeRequestLinesAdded({
+  url,
+  prNumber,
+  accessToken
 }) {
-  const { projectPath } = parseGitlabOwnerAndRepo(repoUrl);
-  const api2 = getGitBeaker({ url: repoUrl, gitlabAuthToken: accessToken });
   try {
-    const res = await api2.Branches.all(projectPath, {
-      //keyset API pagination is not supported by GL for the branch list (at least not the on-prem version)
-      //so for now we stick with the default pagination and just return the first page and limit the results to 1000 entries.
-      //This is a temporary solution until we implement list branches with name search.
-      perPage: MAX_BRANCHES_FETCH,
-      page: 1
+    const { projectPath } = parseGitlabOwnerAndRepo(url);
+    const api2 = getGitBeaker({
+      url,
+      gitlabAuthToken: accessToken
     });
-    res.sort((a, b) => {
-      if (!a.commit?.committed_date || !b.commit?.committed_date) {
-        return 0;
+    const diffs = await api2.MergeRequests.allDiffs(projectPath, prNumber);
+    let linesAdded = 0;
+    for (const diff of diffs) {
+      if (diff.diff) {
+        const addedLines = diff.diff.split("\n").filter(
+          (line) => line.startsWith("+") && !line.startsWith("+++")
+        ).length;
+        linesAdded += addedLines;
       }
-      return new Date(b.commit?.committed_date).getTime() - new Date(a.commit?.committed_date).getTime();
-    });
-    return res.map((branch) => branch.name).slice(0, MAX_BRANCHES_FETCH);
-  } catch (e) {
-    return [];
-  }
-}
-async function createMergeRequest(options) {
-  const { projectPath } = parseGitlabOwnerAndRepo(options.repoUrl);
-  const api2 = getGitBeaker({
-    url: options.repoUrl,
-    gitlabAuthToken: options.accessToken
-  });
-  const res = await api2.MergeRequests.create(
-    projectPath,
-    options.sourceBranchName,
-    options.targetBranchName,
-    options.title,
-    {
-      description: safeBody(options.body, MAX_GITLAB_PR_BODY_LENGTH)
     }
-  );
-  return res.iid;
+    return linesAdded;
+  } catch (error) {
+    contextLogger.warn(
+      "[getGitlabMergeRequestLinesAdded] Failed to fetch diffs for MR",
+      {
+        prNumber,
+        error
+      }
+    );
+    return 0;
+  }
 }
-async function getGitlabMergeRequest({
+async function getGitlabMergeRequestMetrics({
   url,
   prNumber,
   accessToken
@@ -10370,7 +10032,28 @@ async function getGitlabMergeRequest({
     url,
     gitlabAuthToken: accessToken
   });
-  return await api2.MergeRequests.show(projectPath, prNumber);
+  const [mr, commits, linesAdded, notes] = await Promise.all([
+    api2.MergeRequests.show(projectPath, prNumber),
+    api2.MergeRequests.allCommits(projectPath, prNumber),
+    getGitlabMergeRequestLinesAdded({ url, prNumber, accessToken }),
+    api2.MergeRequestNotes.all(projectPath, prNumber)
+  ]);
+  const sortedCommits = [...commits].sort(
+    (a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
+  );
+  const firstCommitDate = sortedCommits[0]?.created_at ?? null;
+  const commentIds = notes.filter((note) => !note.system).map((note) => String(note.id));
+  return {
+    state: mr.state,
+    isDraft: mr.draft ?? false,
+    createdAt: mr.created_at,
+    mergedAt: mr.merged_at ?? null,
+    linesAdded,
+    commitsCount: commits.length,
+    commitShas: commits.map((c) => c.id),
+    firstCommitDate,
+    commentIds
+  };
 }
 async function getGitlabCommitUrl({
   url,
@@ -10449,26 +10132,125 @@ function parseGitlabOwnerAndRepo(gitlabUrl) {
   const { organization, repoName, projectPath } = parsingResult;
   return { owner: organization, repo: repoName, projectPath };
 }
-async function getGitlabBlameRanges({ ref, gitlabUrl, path: path25 }, options) {
-  const { projectPath } = parseGitlabOwnerAndRepo(gitlabUrl);
-  const api2 = getGitBeaker({
-    url: gitlabUrl,
-    gitlabAuthToken: options?.gitlabAuthToken
-  });
-  const resp = await api2.RepositoryFiles.allFileBlames(projectPath, path25, ref);
-  let lineNumber = 1;
-  return resp.filter((range) => range.lines).map((range) => {
-    const oldLineNumber = lineNumber;
-    if (!range.lines) {
-      throw new Error("range.lines should not be undefined");
-    }
-    lineNumber += range.lines.length;
+var GITLAB_MAX_RESULTS_LIMIT = 1024;
+var GITLAB_PER_PAGE = 128;
+async function getGitlabRecentCommits({
+  repoUrl,
+  accessToken,
+  since
+}) {
+  const { projectPath } = parseGitlabOwnerAndRepo(repoUrl);
+  const api2 = getGitBeaker({ url: repoUrl, gitlabAuthToken: accessToken });
+  const allCommits = [];
+  let page = 1;
+  let hasMore = true;
+  while (hasMore && allCommits.length < GITLAB_MAX_RESULTS_LIMIT) {
+    const commits = await api2.Commits.all(projectPath, {
+      since,
+      perPage: GITLAB_PER_PAGE,
+      page
+    });
+    if (commits.length === 0) {
+      hasMore = false;
+      break;
+    }
+    for (const commit of commits) {
+      if (allCommits.length >= GITLAB_MAX_RESULTS_LIMIT) {
+        break;
+      }
+      allCommits.push({
+        sha: commit.id,
+        commit: {
+          committer: commit.committed_date ? { date: commit.committed_date } : void 0,
+          author: {
+            email: commit.author_email,
+            name: commit.author_name
+          },
+          message: commit.message
+        },
+        parents: commit.parent_ids?.map((sha) => ({ sha })) || []
+      });
+    }
+    if (commits.length < GITLAB_PER_PAGE) {
+      hasMore = false;
+    } else {
+      page++;
+    }
+  }
+  if (allCommits.length >= GITLAB_MAX_RESULTS_LIMIT) {
+    contextLogger.warn("[getGitlabRecentCommits] Hit commit pagination limit", {
+      limit: GITLAB_MAX_RESULTS_LIMIT,
+      count: allCommits.length,
+      repoUrl,
+      since
+    });
+  }
+  return allCommits;
+}
+async function getGitlabCommitDiff({
+  repoUrl,
+  accessToken,
+  commitSha
+}) {
+  const { projectPath } = parseGitlabOwnerAndRepo(repoUrl);
+  const api2 = getGitBeaker({ url: repoUrl, gitlabAuthToken: accessToken });
+  const [commit, diffs] = await Promise.all([
+    api2.Commits.show(projectPath, commitSha),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    api2.Commits.showDiff(projectPath, commitSha, { unidiff: true })
+  ]);
+  const diffString = buildUnifiedDiff(diffs);
+  const commitTimestamp = commit.committed_date ? new Date(commit.committed_date) : /* @__PURE__ */ new Date();
+  return {
+    diff: diffString,
+    commitTimestamp,
+    commitSha: commit.id,
+    authorName: commit.author_name,
+    authorEmail: commit.author_email,
+    message: commit.message
+  };
+}
+async function getGitlabRateLimitStatus({
+  repoUrl,
+  accessToken
+}) {
+  try {
+    const api2 = getGitBeaker({ url: repoUrl, gitlabAuthToken: accessToken });
+    const response = await api2.Users.showCurrentUser({ showExpanded: true });
+    const headers = response.headers;
+    if (!headers) {
+      return null;
+    }
+    const remaining = headers["ratelimit-remaining"];
+    const reset = headers["ratelimit-reset"];
+    const limit = headers["ratelimit-limit"];
+    if (!remaining || !reset) {
+      return null;
+    }
+    const remainingNum = parseInt(remaining, 10);
+    const resetNum = parseInt(reset, 10);
+    if (isNaN(remainingNum) || isNaN(resetNum)) {
+      contextLogger.warn(
+        "[getGitlabRateLimitStatus] Malformed rate limit headers",
+        { remaining, reset, repoUrl }
+      );
+      return null;
+    }
     return {
-      startingLine: oldLineNumber,
-      endingLine: lineNumber - 1,
-      commitSha: range.commit.id
+      remaining: remainingNum,
+      reset: new Date(resetNum * 1e3),
+      limit: limit ? parseInt(limit, 10) : void 0
     };
-  });
+  } catch (error) {
+    contextLogger.warn(
+      "[getGitlabRateLimitStatus] Error fetching rate limit status",
+      {
+        error: error instanceof Error ? error.message : String(error),
+        repoUrl
+      }
+    );
+    return null;
+  }
 }
 async function processBody(response) {
   const headers = response.headers;
@@ -10509,8 +10291,90 @@ async function brokerRequestHandler(endpoint, options) {
     };
   throw new Error(`gitbeaker: ${response.statusText}`);
 }
+async function getGitlabMergeRequestDiff({
+  repoUrl,
+  accessToken,
+  mrNumber
+}) {
+  debug4("[getGitlabMergeRequestDiff] Starting for MR #%d", mrNumber);
+  const { projectPath } = parseGitlabOwnerAndRepo(repoUrl);
+  const api2 = getGitBeaker({ url: repoUrl, gitlabAuthToken: accessToken });
+  debug4(
+    "[getGitlabMergeRequestDiff] Fetching MR details, diffs, and commits..."
+  );
+  const startMrFetch = Date.now();
+  const [mr, mrDiffs, mrCommitsRaw] = await Promise.all([
+    api2.MergeRequests.show(projectPath, mrNumber),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    api2.MergeRequests.allDiffs(projectPath, mrNumber, { unidiff: true }),
+    api2.MergeRequests.allCommits(projectPath, mrNumber)
+  ]);
+  debug4(
+    "[getGitlabMergeRequestDiff] MR fetch took %dms. Diffs: %d, Commits: %d",
+    Date.now() - startMrFetch,
+    mrDiffs.length,
+    mrCommitsRaw.length
+  );
+  const diffString = buildUnifiedDiff(mrDiffs);
+  debug4(
+    "[getGitlabMergeRequestDiff] Fetching commit diffs for %d commits...",
+    mrCommitsRaw.length
+  );
+  const startCommitFetch = Date.now();
+  const commitDiffLimit = pLimit2(GITLAB_API_CONCURRENCY);
+  const commits = await Promise.all(
+    mrCommitsRaw.map(
+      (commit) => commitDiffLimit(async () => {
+        const commitDiff = await getGitlabCommitDiff({
+          repoUrl,
+          accessToken,
+          commitSha: commit.id
+        });
+        return {
+          diff: commitDiff.diff,
+          commitTimestamp: commitDiff.commitTimestamp,
+          commitSha: commitDiff.commitSha,
+          authorName: commitDiff.authorName,
+          authorEmail: commitDiff.authorEmail,
+          message: commitDiff.message
+        };
+      })
+    )
+  );
+  commits.sort(
+    (a, b) => new Date(a.commitTimestamp).getTime() - new Date(b.commitTimestamp).getTime()
+  );
+  debug4(
+    "[getGitlabMergeRequestDiff] Commit diffs fetch took %dms",
+    Date.now() - startCommitFetch
+  );
+  const addedLinesByFile = parseAddedLinesByFile(diffString);
+  const diffLines = [];
+  for (const [file, lines] of addedLinesByFile) {
+    for (const line of lines) {
+      diffLines.push({ file, line });
+    }
+  }
+  return {
+    diff: diffString,
+    createdAt: new Date(mr.created_at),
+    updatedAt: new Date(mr.updated_at),
+    submitRequestId: String(mrNumber),
+    submitRequestNumber: mrNumber,
+    sourceBranch: mr.source_branch,
+    targetBranch: mr.target_branch,
+    authorName: mr.author?.name || mr.author?.username,
+    authorEmail: void 0,
+    // GitLab MR API doesn't expose author email directly
+    title: mr.title,
+    description: mr.description || void 0,
+    commits,
+    diffLines
+  };
+}
 
 // src/features/analysis/scm/gitlab/GitlabSCMLib.ts
+init_client_generates();
 var GitlabSCMLib = class extends SCMLib {
   constructor(url, accessToken, scmOrg) {
     super(url, accessToken, scmOrg);
@@ -10537,7 +10401,7 @@ var GitlabSCMLib = class extends SCMLib {
   }
   async getRepoList(_scmOrg) {
     if (!this.accessToken) {
-      console.error("no access token");
+      contextLogger.warn("[GitlabSCMLib.getRepoList] No access token provided");
       throw new Error("no access token");
     }
     return getGitlabRepoList(this.url, this.accessToken);
@@ -10629,16 +10493,6 @@ var GitlabSCMLib = class extends SCMLib {
       markdownComment: comment
     });
   }
-  async getRepoBlameRanges(ref, path25) {
-    this._validateUrl();
-    return await getGitlabBlameRanges(
-      { ref, path: path25, gitlabUrl: this.url },
-      {
-        url: this.url,
-        gitlabAuthToken: this.accessToken
-      }
-    );
-  }
   async getReferenceData(ref) {
     this._validateUrl();
     return await getGitlabReferenceData(
@@ -10682,25 +10536,180 @@ var GitlabSCMLib = class extends SCMLib {
     this._validateAccessTokenAndUrl();
     return `${this.url}/-/commits/${branchName}`;
   }
-  async getCommitDiff(_commitSha) {
-    throw new Error("getCommitDiff not implemented for GitLab");
+  async getCommitDiff(commitSha) {
+    this._validateAccessTokenAndUrl();
+    const result = await getGitlabCommitDiff({
+      repoUrl: this.url,
+      accessToken: this.accessToken,
+      commitSha
+    });
+    return {
+      diff: result.diff,
+      commitTimestamp: result.commitTimestamp,
+      commitSha: result.commitSha,
+      authorName: result.authorName,
+      authorEmail: result.authorEmail,
+      message: result.message
+    };
   }
-  async getSubmitRequestDiff(_submitRequestId) {
-    throw new Error("getSubmitRequestDiff not implemented for GitLab");
+  async getSubmitRequestDiff(submitRequestId) {
+    this._validateAccessTokenAndUrl();
+    const mrNumber = parseInt(submitRequestId, 10);
+    if (isNaN(mrNumber) || mrNumber <= 0) {
+      throw new Error(`Invalid merge request ID: ${submitRequestId}`);
+    }
+    return getGitlabMergeRequestDiff({
+      repoUrl: this.url,
+      accessToken: this.accessToken,
+      mrNumber
+    });
+  }
+  async searchSubmitRequests(params) {
+    this._validateAccessTokenAndUrl();
+    const page = parseCursorSafe(params.cursor, 1);
+    const perPage = params.limit || 10;
+    const sort = params.sort || { field: "updated", order: "desc" };
+    const orderBy = sort.field === "created" ? "created_at" : "updated_at";
+    let gitlabState;
+    if (params.filters?.state === "open") {
+      gitlabState = "opened";
+    } else if (params.filters?.state === "closed") {
+      gitlabState = "closed";
+    } else {
+      gitlabState = "all";
+    }
+    const searchResult = await searchGitlabMergeRequests({
+      repoUrl: this.url,
+      accessToken: this.accessToken,
+      state: gitlabState,
+      updatedAfter: params.filters?.updatedAfter,
+      orderBy,
+      sort: sort.order,
+      perPage,
+      page
+    });
+    const results = searchResult.items.map((mr) => {
+      let status = "open";
+      if (mr.state === "merged") {
+        status = "merged";
+      } else if (mr.state === "closed") {
+        status = "closed";
+      }
+      return {
+        submitRequestId: String(mr.iid),
+        submitRequestNumber: mr.iid,
+        title: mr.title,
+        status,
+        sourceBranch: mr.sourceBranch,
+        targetBranch: mr.targetBranch,
+        authorName: mr.authorUsername,
+        authorEmail: void 0,
+        createdAt: new Date(mr.createdAt),
+        updatedAt: new Date(mr.updatedAt),
+        description: mr.description || void 0,
+        tickets: [],
+        changedLines: { added: 0, removed: 0 }
+      };
+    });
+    const MAX_TOTAL_RESULTS = 1024;
+    const totalFetchedSoFar = page * perPage;
+    const reachedLimit = totalFetchedSoFar >= MAX_TOTAL_RESULTS;
+    if (reachedLimit && searchResult.hasMore) {
+      contextLogger.warn(
+        "[searchSubmitRequests] Hit limit of merge requests for GitLab repo",
+        {
+          limit: MAX_TOTAL_RESULTS
+        }
+      );
+    }
+    return {
+      results,
+      nextCursor: searchResult.hasMore && !reachedLimit ? String(page + 1) : void 0,
+      hasMore: searchResult.hasMore && !reachedLimit
+    };
   }
-  async getSubmitRequests(_repoUrl) {
-    throw new Error("getSubmitRequests not implemented for GitLab");
+  async getPrCommitsBatch(_repoUrl, prNumbers) {
+    this._validateAccessTokenAndUrl();
+    return getGitlabMrCommitsBatch({
+      repoUrl: this.url,
+      accessToken: this.accessToken,
+      mrNumbers: prNumbers
+    });
   }
-  async searchSubmitRequests(_params) {
-    throw new Error("searchSubmitRequests not implemented for GitLab");
+  async getPrDataBatch(_repoUrl, prNumbers) {
+    this._validateAccessTokenAndUrl();
+    return getGitlabMrDataBatch({
+      repoUrl: this.url,
+      accessToken: this.accessToken,
+      mrNumbers: prNumbers
+    });
   }
   async searchRepos(_params) {
     throw new Error("searchRepos not implemented for GitLab");
   }
-  // TODO: Add comprehensive tests for getPullRequestMetrics (GitLab)
-  // See clients/cli/src/features/analysis/scm/__tests__/github.test.ts:589-648 for reference
-  async getPullRequestMetrics(_prNumber) {
-    throw new Error("getPullRequestMetrics not implemented for GitLab");
+  async getPullRequestMetrics(prNumber) {
+    this._validateAccessTokenAndUrl();
+    const metrics = await getGitlabMergeRequestMetrics({
+      url: this.url,
+      prNumber,
+      accessToken: this.accessToken
+    });
+    let prStatus;
+    switch (metrics.state) {
+      case "merged":
+        prStatus = "MERGED" /* Merged */;
+        break;
+      case "closed":
+        prStatus = "CLOSED" /* Closed */;
+        break;
+      default:
+        prStatus = metrics.isDraft ? "DRAFT" /* Draft */ : "ACTIVE" /* Active */;
+    }
+    return {
+      prId: String(prNumber),
+      repositoryUrl: this.url,
+      prCreatedAt: new Date(metrics.createdAt),
+      prMergedAt: metrics.mergedAt ? new Date(metrics.mergedAt) : null,
+      firstCommitDate: metrics.firstCommitDate ? new Date(metrics.firstCommitDate) : null,
+      linesAdded: metrics.linesAdded,
+      commitsCount: metrics.commitsCount,
+      commitShas: metrics.commitShas,
+      prStatus,
+      commentIds: metrics.commentIds
+    };
+  }
+  async getRecentCommits(since) {
+    this._validateAccessTokenAndUrl();
+    const commits = await getGitlabRecentCommits({
+      repoUrl: this.url,
+      accessToken: this.accessToken,
+      since
+    });
+    return { data: commits };
+  }
+  async getRateLimitStatus() {
+    this._validateAccessTokenAndUrl();
+    return getGitlabRateLimitStatus({
+      repoUrl: this.url,
+      accessToken: this.accessToken
+    });
+  }
+  /**
+   * Extract Linear ticket links from pre-fetched comments (pure function, no API calls).
+   * Linear bot uses the same comment format on GitLab as on GitHub.
+   * Bot username may be 'linear' or 'linear[bot]' on GitLab.
+   */
+  extractLinearTicketsFromComments(comments) {
+    const tickets = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const comment of comments) {
+      const authorLogin = comment.author?.login?.toLowerCase() || "";
+      const isLinearBot = authorLogin === "linear" || authorLogin === "linear[bot]" || comment.author?.type === "Bot" && authorLogin.includes("linear");
+      if (isLinearBot) {
+        tickets.push(...extractLinearTicketsFromBody(comment.body || "", seen));
+      }
+    }
+    return tickets;
   }
 };
 
@@ -10759,10 +10768,6 @@ var StubSCMLib = class extends SCMLib {
     console.warn("getUserHasAccessToRepo() returning false");
     return false;
   }
-  async getRepoBlameRanges(_ref, _path) {
-    console.warn("getRepoBlameRanges() returning empty array");
-    return [];
-  }
   async getReferenceData(_ref) {
     console.warn("getReferenceData() returning null/empty defaults");
     return {
@@ -10827,14 +10832,18 @@ var StubSCMLib = class extends SCMLib {
       diffLines: []
     };
   }
-  async getSubmitRequests(_repoUrl) {
-    console.warn("getSubmitRequests() returning empty array");
-    return [];
-  }
   async getPullRequestMetrics(_prNumber) {
     console.warn("getPullRequestMetrics() returning empty object");
     throw new Error("getPullRequestMetrics() not implemented");
   }
+  async getRecentCommits(_since) {
+    console.warn("getRecentCommits() returning empty array");
+    return { data: [] };
+  }
+  async getRateLimitStatus() {
+    console.warn("getRateLimitStatus() returning null");
+    return null;
+  }
 };
 
 // src/features/analysis/scm/scmFactory.ts
@@ -12855,7 +12864,7 @@ import Debug10 from "debug";
 
 // src/features/analysis/add_fix_comments_for_pr/utils/utils.ts
 import Debug9 from "debug";
-import parseDiff from "parse-diff";
+import parseDiff2 from "parse-diff";
 import { z as z27 } from "zod";
 
 // src/features/analysis/utils/by_key.ts
@@ -13228,7 +13237,7 @@ Refresh the page in order to see the changes.`,
 }
 async function getRelevantVulenrabilitiesFromDiff(params) {
   const { gqlClient, diff, vulnerabilityReportId } = params;
-  const parsedDiff = parseDiff(diff);
+  const parsedDiff = parseDiff2(diff);
   const fileHunks = parsedDiff.map((file) => {
     const fileNumbers = file.chunks.flatMap((chunk) => chunk.changes).filter((change) => change.type === "add").map((_change) => {
       const change = _change;
@@ -15329,7 +15338,7 @@ async function getRepositoryUrl() {
     }
     const remoteUrl = await gitService.getRemoteUrl();
     const parsed = parseScmURL(remoteUrl);
-    return parsed?.scmType === "GitHub" /* GitHub */ ? remoteUrl : null;
+    return parsed?.scmType === "GitHub" /* GitHub */ || parsed?.scmType === "GitLab" /* GitLab */ ? remoteUrl : null;
   } catch {
     return null;
   }
@@ -21495,7 +21504,7 @@ import {
   writeFileSync
 } from "fs";
 import fs21 from "fs/promises";
-import parseDiff2 from "parse-diff";
+import parseDiff3 from "parse-diff";
 import path20 from "path";
 var PatchApplicationService = class {
   /**
@@ -22179,7 +22188,7 @@ var PatchApplicationService = class {
     fixId,
     scanContext
   }) {
-    const parsedPatch = parseDiff2(patch);
+    const parsedPatch = parseDiff3(patch);
     if (!parsedPatch || parsedPatch.length === 0) {
       throw new Error("Failed to parse patch - no changes found");
     }