mobbdev 1.0.213 → 1.0.216

package/dist/index.mjs

@@ -1371,6 +1371,12 @@ import { z as z14 } from "zod";
 import { z as z2 } from "zod";
 
 // src/features/analysis/scm/generates/client_generates.ts
+var AiBlameInferenceType = /* @__PURE__ */ ((AiBlameInferenceType2) => {
+  AiBlameInferenceType2["Chat"] = "CHAT";
+  AiBlameInferenceType2["HumanEdit"] = "HUMAN_EDIT";
+  AiBlameInferenceType2["TabAutocomplete"] = "TAB_AUTOCOMPLETE";
+  return AiBlameInferenceType2;
+})(AiBlameInferenceType || {});
 var FixQuestionInputType = /* @__PURE__ */ ((FixQuestionInputType2) => {
   FixQuestionInputType2["Number"] = "NUMBER";
   FixQuestionInputType2["Select"] = "SELECT";
@@ -1820,6 +1826,20 @@ var GetLastOrgAndNamedProjectDocument = `
   }
 }
     `;
+var GetLastOrgDocument = `
+    query getLastOrg($email: String!) {
+  user(where: {email: {_eq: $email}}, limit: 1) {
+    id
+    name
+    userOrganizationsAndUserOrganizationRoles(order_by: {createdOn: desc}) {
+      id
+      organization {
+        id
+      }
+    }
+  }
+}
+    `;
 var GetEncryptedApiTokenDocument = `
     query GetEncryptedApiToken($loginId: uuid!) {
   cli_login_by_pk(id: $loginId) {
@@ -2315,6 +2335,9 @@ function getSdk(client, withWrapper = defaultWrapper) {
     getLastOrgAndNamedProject(variables, requestHeaders, signal) {
       return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLastOrgAndNamedProjectDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getLastOrgAndNamedProject", "query", variables);
     },
+    getLastOrg(variables, requestHeaders, signal) {
+      return withWrapper((wrappedRequestHeaders) => client.request({ document: GetLastOrgDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "getLastOrg", "query", variables);
+    },
     GetEncryptedApiToken(variables, requestHeaders, signal) {
       return withWrapper((wrappedRequestHeaders) => client.request({ document: GetEncryptedApiTokenDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), "GetEncryptedApiToken", "query", variables);
     },
@@ -6224,7 +6247,7 @@ async function getAdoSdk(params) {
       const url = new URL(repoUrl);
       const origin2 = url.origin.toLowerCase().endsWith(".visualstudio.com") ? DEFUALT_ADO_ORIGIN : url.origin.toLowerCase();
       const params2 = `path=/&versionDescriptor[versionOptions]=0&versionDescriptor[versionType]=commit&versionDescriptor[version]=${branch}&resolveLfs=true&$format=zip&api-version=5.0&download=true`;
-      const path18 = [
+      const path21 = [
         prefixPath,
         owner,
         projectName,
@@ -6235,7 +6258,7 @@ async function getAdoSdk(params) {
         "items",
         "items"
       ].filter(Boolean).join("/");
-      return new URL(`${path18}?${params2}`, origin2).toString();
+      return new URL(`${path21}?${params2}`, origin2).toString();
     },
     async getAdoBranchList({ repoUrl }) {
       try {
@@ -7782,14 +7805,14 @@ function getGithubSdk(params = {}) {
       };
     },
     async getGithubBlameRanges(params2) {
-      const { ref, gitHubUrl, path: path18 } = params2;
+      const { ref, gitHubUrl, path: path21 } = params2;
       const { owner, repo } = parseGithubOwnerAndRepo(gitHubUrl);
       const res = await octokit.graphql(
         GET_BLAME_DOCUMENT,
         {
           owner,
           repo,
-          path: path18,
+          path: path21,
           ref
         }
       );
@@ -7942,6 +7965,23 @@ function getGithubSdk(params = {}) {
         per_page: 100
       });
     },
+    async getRecentCommits(params2) {
+      const commits = await octokit.paginate(octokit.rest.repos.listCommits, {
+        owner: params2.owner,
+        repo: params2.repo,
+        since: params2.since,
+        per_page: 100
+      });
+      return { data: commits };
+    },
+    async getRateLimitStatus() {
+      const response = await octokit.rest.rateLimit.get();
+      return {
+        remaining: response.data.rate.remaining,
+        reset: new Date(response.data.rate.reset * 1e3),
+        limit: response.data.rate.limit
+      };
+    },
     async getRepoPullRequests(params2) {
       return octokit.rest.pulls.list({
         owner: params2.owner,
@@ -8075,6 +8115,14 @@ var GithubSCMLib = class extends SCMLib {
     const branches = await this.githubSdk.getGithubBranchList(this.url);
     return branches.data.map((branch) => branch.name);
   }
+  async getRecentCommits(since) {
+    this._validateAccessTokenAndUrl();
+    const { owner, repo } = parseGithubOwnerAndRepo(this.url);
+    return await this.githubSdk.getRecentCommits({ owner, repo, since });
+  }
+  async getRateLimitStatus() {
+    return await this.githubSdk.getRateLimitStatus();
+  }
   get scmLibType() {
     return "GITHUB" /* GITHUB */;
   }
@@ -8131,11 +8179,11 @@ var GithubSCMLib = class extends SCMLib {
       markdownComment: comment
     });
   }
-  async getRepoBlameRanges(ref, path18) {
+  async getRepoBlameRanges(ref, path21) {
     this._validateUrl();
     return await this.githubSdk.getGithubBlameRanges({
       ref,
-      path: path18,
+      path: path21,
       gitHubUrl: this.url
     });
   }
@@ -8815,13 +8863,13 @@ function parseGitlabOwnerAndRepo(gitlabUrl) {
   const { organization, repoName, projectPath } = parsingResult;
   return { owner: organization, repo: repoName, projectPath };
 }
-async function getGitlabBlameRanges({ ref, gitlabUrl, path: path18 }, options) {
+async function getGitlabBlameRanges({ ref, gitlabUrl, path: path21 }, options) {
   const { projectPath } = parseGitlabOwnerAndRepo(gitlabUrl);
   const api2 = getGitBeaker({
     url: gitlabUrl,
     gitlabAuthToken: options?.gitlabAuthToken
   });
-  const resp = await api2.RepositoryFiles.allFileBlames(projectPath, path18, ref);
+  const resp = await api2.RepositoryFiles.allFileBlames(projectPath, path21, ref);
   let lineNumber = 1;
   return resp.filter((range) => range.lines).map((range) => {
     const oldLineNumber = lineNumber;
@@ -8998,10 +9046,10 @@ var GitlabSCMLib = class extends SCMLib {
       markdownComment: comment
     });
   }
-  async getRepoBlameRanges(ref, path18) {
+  async getRepoBlameRanges(ref, path21) {
     this._validateUrl();
     return await getGitlabBlameRanges(
-      { ref, path: path18, gitlabUrl: this.url },
+      { ref, path: path21, gitlabUrl: this.url },
       {
         url: this.url,
         gitlabAuthToken: this.accessToken
@@ -10354,6 +10402,13 @@ var GQLClient = class {
     const { me } = await this._clientSdk.Me();
     return me;
   }
+  async getLastOrg(email) {
+    const getLastOrgRes = await this._clientSdk.getLastOrg({ email });
+    return {
+      organizationId: getLastOrgRes?.user?.[0]?.userOrganizationsAndUserOrganizationRoles?.[0]?.organization?.id,
+      userName: getLastOrgRes?.user?.[0]?.name ?? ""
+    };
+  }
   async createCliLogin(variables) {
     const res = await this._clientSdk.CreateCliLogin(variables, {
       // We may have outdated API key in the config storage. Avoid using it for the login request.
@@ -11033,7 +11088,7 @@ async function postIssueComment(params) {
     fpDescription
   } = params;
   const {
-    path: path18,
+    path: path21,
     startLine,
     vulnerabilityReportIssue: {
       vulnerabilityReportIssueTags,
@@ -11048,7 +11103,7 @@ async function postIssueComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path18,
+    path: path21,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -11082,7 +11137,7 @@ async function postFixComment(params) {
     scanner
   } = params;
   const {
-    path: path18,
+    path: path21,
     startLine,
     vulnerabilityReportIssue: { fixId, vulnerabilityReportIssueTags, category },
     vulnerabilityReportIssueId
@@ -11100,7 +11155,7 @@ async function postFixComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path18,
+    path: path21,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -11681,8 +11736,8 @@ if (typeof __filename !== "undefined") {
 }
 var costumeRequire = createRequire(moduleUrl);
 var getCheckmarxPath = () => {
-  const os6 = type();
-  const cxFileName = os6 === "Windows_NT" ? "cx.exe" : "cx";
+  const os9 = type();
+  const cxFileName = os9 === "Windows_NT" ? "cx.exe" : "cx";
   try {
     return costumeRequire.resolve(`.bin/${cxFileName}`);
   } catch (e) {
@@ -12858,8 +12913,8 @@ var WorkspaceService = class {
    * Sets a known workspace path that was discovered through successful validation
    * @param path The validated workspace path to store
    */
-  static setKnownWorkspacePath(path18) {
-    this.knownWorkspacePath = path18;
+  static setKnownWorkspacePath(path21) {
+    this.knownWorkspacePath = path21;
   }
   /**
    * Gets the known workspace path that was previously validated
@@ -14072,16 +14127,16 @@ var versionCommands = {
   }
 };
 var getProcessInfo = (pid) => {
-  const platform = os3.platform();
+  const platform2 = os3.platform();
   try {
-    if (platform === "linux" || platform === "darwin") {
+    if (platform2 === "linux" || platform2 === "darwin") {
       const output = execSync(`ps -o pid=,ppid=,comm= -p ${pid}`, {
         stdio: ["pipe", "pipe", "ignore"]
       }).toString().trim();
       if (!output) return null;
       const [pidStr, ppid, ...cmd] = output.trim().split(/\s+/);
       return { pid: pidStr ?? "", ppid: ppid ?? "", cmd: cmd.join(" ") };
-    } else if (platform === "win32") {
+    } else if (platform2 === "win32") {
       const output = execSync(
         `powershell -Command "Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}' | Select-Object ProcessId,ParentProcessId,Name | Format-Table -HideTableHeaders"`,
         { stdio: ["pipe", "pipe", "ignore"] }
@@ -14093,7 +14148,7 @@ var getProcessInfo = (pid) => {
       const cmd = parts.slice(2).join(" ");
       return { pid: pidStr ?? "", ppid: ppid ?? "", cmd };
     } else {
-      logWarn(`[UsageService] Unsupported platform: ${platform}`);
+      logWarn(`[UsageService] Unsupported platform: ${platform2}`);
       return null;
     }
   } catch {
@@ -14107,10 +14162,10 @@ var getHostInfo = (additionalMcpList) => {
   const ideConfigPaths = /* @__PURE__ */ new Set();
   for (const ide of IDEs) {
     const configPaths = getMCPConfigPaths(ide);
-    configPaths.forEach((path18) => ideConfigPaths.add(path18));
+    configPaths.forEach((path21) => ideConfigPaths.add(path21));
   }
   const uniqueAdditionalPaths = additionalMcpList.filter(
-    (path18) => !ideConfigPaths.has(path18)
+    (path21) => !ideConfigPaths.has(path21)
   );
   for (const ide of IDEs) {
     const cfg = readMCPConfig(ide);
@@ -14191,8 +14246,8 @@ var getHostInfo = (additionalMcpList) => {
     const config6 = allConfigs[ide] || null;
     const ideName = ide.charAt(0).toUpperCase() + ide.slice(1) || "Unknown";
     let ideVersion = "Unknown";
-    const platform = os3.platform();
-    const cmds = versionCommands[ideName]?.[platform] ?? [];
+    const platform2 = os3.platform();
+    const cmds = versionCommands[ideName]?.[platform2] ?? [];
     for (const cmd of cmds) {
       try {
         const versionOutput = cmd.includes("grep") || cmd.includes("--version") || cmd.includes("sed") ? execSync(cmd, { stdio: ["pipe", "pipe", "ignore"] }).toString().split("\n")[0] ?? "" : cmd;
@@ -14267,8 +14322,8 @@ var searchDir = async (dir, depth = 0) => {
 var findSystemMCPConfigs = async () => {
   try {
     const home = os4.homedir();
-    const platform = os4.platform();
-    const knownDirs = platform === "win32" ? [
+    const platform2 = os4.platform();
+    const knownDirs = platform2 === "win32" ? [
       path12.join(home, ".cursor"),
       path12.join(home, "Documents"),
       path12.join(home, "Downloads")
@@ -16691,12 +16746,32 @@ For a complete security audit workflow, use the \`full-security-audit\` prompt.
   }
 };
 
+// src/mcp/services/McpDetectionService/CursorMcpDetectionService.ts
+import * as fs15 from "fs";
+import * as os7 from "os";
+import * as path14 from "path";
+
+// src/mcp/services/McpDetectionService/BaseMcpDetectionService.ts
+init_configs();
+import * as fs14 from "fs";
+import fetch6 from "node-fetch";
+import * as path13 from "path";
+
+// src/mcp/services/McpDetectionService/McpDetectionServiceUtils.ts
+import * as fs13 from "fs";
+import * as os6 from "os";
+
+// src/mcp/services/McpDetectionService/VscodeMcpDetectionService.ts
+import * as fs16 from "fs";
+import * as os8 from "os";
+import * as path15 from "path";
+
 // src/mcp/tools/checkForNewAvailableFixes/CheckForNewAvailableFixesTool.ts
 import { z as z40 } from "zod";
 
 // src/mcp/services/PathValidation.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs17 from "fs";
+import path16 from "path";
 async function validatePath(inputPath) {
   logDebug("Validating MCP path", { inputPath });
   if (/^\/[a-zA-Z]:\//.test(inputPath)) {
@@ -16728,7 +16803,7 @@ async function validatePath(inputPath) {
     logError(error);
     return { isValid: false, error, path: inputPath };
   }
-  const normalizedPath = path13.normalize(inputPath);
+  const normalizedPath = path16.normalize(inputPath);
   if (normalizedPath.includes("..")) {
     const error = `Normalized path contains path traversal patterns: ${inputPath}`;
     logError(error);
@@ -16755,7 +16830,7 @@ async function validatePath(inputPath) {
   logDebug("Path validation successful", { inputPath });
   logDebug("Checking path existence", { inputPath });
   try {
-    await fs13.promises.access(inputPath);
+    await fs17.promises.access(inputPath);
     logDebug("Path exists and is accessible", { inputPath });
     WorkspaceService.setKnownWorkspacePath(inputPath);
     logDebug("Stored validated path in WorkspaceService", { inputPath });
@@ -17379,10 +17454,10 @@ If you wish to scan files that were recently changed in your git history call th
 init_FileUtils();
 init_GitService();
 init_configs();
-import fs14 from "fs/promises";
+import fs18 from "fs/promises";
 import nodePath from "path";
 var getLocalFiles = async ({
-  path: path18,
+  path: path21,
   maxFileSize = MCP_MAX_FILE_SIZE,
   maxFiles,
   isAllFilesScan,
@@ -17390,17 +17465,17 @@ var getLocalFiles = async ({
   scanRecentlyChangedFiles
 }) => {
   logDebug(`[${scanContext}] Starting getLocalFiles`, {
-    path: path18,
+    path: path21,
     maxFileSize,
     maxFiles,
     isAllFilesScan,
     scanRecentlyChangedFiles
   });
   try {
-    const resolvedRepoPath = await fs14.realpath(path18);
+    const resolvedRepoPath = await fs18.realpath(path21);
     logDebug(`[${scanContext}] Resolved repository path`, {
       resolvedRepoPath,
-      originalPath: path18
+      originalPath: path21
     });
     const gitService = new GitService(resolvedRepoPath, log);
     const gitValidation = await gitService.validateRepository();
@@ -17413,7 +17488,7 @@ var getLocalFiles = async ({
     if (!gitValidation.isValid || isAllFilesScan) {
       try {
         files = await FileUtils.getLastChangedFiles({
-          dir: path18,
+          dir: path21,
           maxFileSize,
           maxFiles,
           isAllFilesScan
@@ -17477,7 +17552,7 @@ var getLocalFiles = async ({
           absoluteFilePath
         );
         try {
-          const fileStat = await fs14.stat(absoluteFilePath);
+          const fileStat = await fs18.stat(absoluteFilePath);
           return {
             filename: nodePath.basename(absoluteFilePath),
             relativePath,
@@ -17505,15 +17580,15 @@ var getLocalFiles = async ({
     logError(`${scanContext}Unexpected error in getLocalFiles`, {
       error: error instanceof Error ? error.message : String(error),
       stack: error instanceof Error ? error.stack : void 0,
-      path: path18
+      path: path21
     });
     throw error;
   }
 };
 
 // src/mcp/services/LocalMobbFolderService.ts
-import fs15 from "fs";
-import path14 from "path";
+import fs19 from "fs";
+import path17 from "path";
 import { z as z39 } from "zod";
 init_GitService();
 function extractPathFromPatch(patch) {
@@ -17600,19 +17675,19 @@ var LocalMobbFolderService = class {
           "[LocalMobbFolderService] Non-git repository detected, skipping .gitignore operations"
         );
       }
-      const mobbFolderPath = path14.join(
+      const mobbFolderPath = path17.join(
         this.repoPath,
         this.defaultMobbFolderName
       );
-      if (!fs15.existsSync(mobbFolderPath)) {
+      if (!fs19.existsSync(mobbFolderPath)) {
         logInfo("[LocalMobbFolderService] Creating .mobb folder", {
           mobbFolderPath
         });
-        fs15.mkdirSync(mobbFolderPath, { recursive: true });
+        fs19.mkdirSync(mobbFolderPath, { recursive: true });
       } else {
         logDebug("[LocalMobbFolderService] .mobb folder already exists");
       }
-      const stats = fs15.statSync(mobbFolderPath);
+      const stats = fs19.statSync(mobbFolderPath);
       if (!stats.isDirectory()) {
         throw new Error(`Path exists but is not a directory: ${mobbFolderPath}`);
       }
@@ -17653,13 +17728,13 @@ var LocalMobbFolderService = class {
       logDebug("[LocalMobbFolderService] Git repository validated successfully");
     } else {
       try {
-        const stats = fs15.statSync(this.repoPath);
+        const stats = fs19.statSync(this.repoPath);
         if (!stats.isDirectory()) {
           throw new Error(
             `Path exists but is not a directory: ${this.repoPath}`
           );
         }
-        fs15.accessSync(this.repoPath, fs15.constants.R_OK | fs15.constants.W_OK);
+        fs19.accessSync(this.repoPath, fs19.constants.R_OK | fs19.constants.W_OK);
         logDebug(
           "[LocalMobbFolderService] Non-git directory validated successfully"
         );
@@ -17772,8 +17847,8 @@ var LocalMobbFolderService = class {
         mobbFolderPath,
         baseFileName
       );
-      const filePath = path14.join(mobbFolderPath, uniqueFileName);
-      await fs15.promises.writeFile(filePath, patch, "utf8");
+      const filePath = path17.join(mobbFolderPath, uniqueFileName);
+      await fs19.promises.writeFile(filePath, patch, "utf8");
       logInfo("[LocalMobbFolderService] Patch saved successfully", {
         filePath,
         fileName: uniqueFileName,
@@ -17830,11 +17905,11 @@ var LocalMobbFolderService = class {
    * @returns Unique filename that doesn't conflict with existing files
    */
   getUniqueFileName(folderPath, baseFileName) {
-    const baseName = path14.parse(baseFileName).name;
-    const extension = path14.parse(baseFileName).ext;
+    const baseName = path17.parse(baseFileName).name;
+    const extension = path17.parse(baseFileName).ext;
     let uniqueFileName = baseFileName;
     let index = 1;
-    while (fs15.existsSync(path14.join(folderPath, uniqueFileName))) {
+    while (fs19.existsSync(path17.join(folderPath, uniqueFileName))) {
       uniqueFileName = `${baseName}-${index}${extension}`;
       index++;
       if (index > 1e3) {
@@ -17865,18 +17940,18 @@ var LocalMobbFolderService = class {
     logDebug("[LocalMobbFolderService] Logging patch info", { fixId: fix.id });
     try {
       const mobbFolderPath = await this.getFolder();
-      const patchInfoPath = path14.join(mobbFolderPath, "patchInfo.md");
+      const patchInfoPath = path17.join(mobbFolderPath, "patchInfo.md");
       const markdownContent = this.generateFixMarkdown(fix, savedPatchFileName);
       let existingContent = "";
-      if (fs15.existsSync(patchInfoPath)) {
-        existingContent = await fs15.promises.readFile(patchInfoPath, "utf8");
+      if (fs19.existsSync(patchInfoPath)) {
+        existingContent = await fs19.promises.readFile(patchInfoPath, "utf8");
         logDebug("[LocalMobbFolderService] Existing patchInfo.md found");
       } else {
         logDebug("[LocalMobbFolderService] Creating new patchInfo.md file");
       }
       const separator = existingContent ? "\n\n================================================================================\n\n" : "";
       const updatedContent = `${markdownContent}${separator}${existingContent}`;
-      await fs15.promises.writeFile(patchInfoPath, updatedContent, "utf8");
+      await fs19.promises.writeFile(patchInfoPath, updatedContent, "utf8");
       logInfo("[LocalMobbFolderService] Patch info logged successfully", {
         patchInfoPath,
         fixId: fix.id,
@@ -17907,7 +17982,7 @@ var LocalMobbFolderService = class {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const patch = this.extractPatchFromFix(fix);
     const relativePatchedFilePath = patch ? extractPathFromPatch(patch) : null;
-    const patchedFilePath = relativePatchedFilePath ? path14.resolve(this.repoPath, relativePatchedFilePath) : null;
+    const patchedFilePath = relativePatchedFilePath ? path17.resolve(this.repoPath, relativePatchedFilePath) : null;
     const fixIdentifier = savedPatchFileName ? savedPatchFileName.replace(".patch", "") : fix.id;
     let markdown = `# Fix ${fixIdentifier}
 
@@ -18243,22 +18318,22 @@ var LocalMobbFolderService = class {
 // src/mcp/services/PatchApplicationService.ts
 init_configs();
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync6,
   mkdirSync,
-  readFileSync,
+  readFileSync as readFileSync3,
   unlinkSync,
   writeFileSync
 } from "fs";
-import fs16 from "fs/promises";
+import fs20 from "fs/promises";
 import parseDiff2 from "parse-diff";
-import path15 from "path";
+import path18 from "path";
 var PatchApplicationService = class {
   /**
    * Gets the appropriate comment syntax for a file based on its extension
    */
   static getCommentSyntax(filePath) {
-    const ext = path15.extname(filePath).toLowerCase();
-    const basename2 = path15.basename(filePath);
+    const ext = path18.extname(filePath).toLowerCase();
+    const basename2 = path18.basename(filePath);
     const commentMap = {
       // C-style languages (single line comments)
       ".js": "//",
@@ -18461,7 +18536,7 @@ var PatchApplicationService = class {
         }
       );
     }
-    const dirPath = path15.dirname(filePath);
+    const dirPath = path18.dirname(filePath);
     mkdirSync(dirPath, { recursive: true });
     writeFileSync(filePath, finalContent, "utf8");
     return filePath;
@@ -18745,9 +18820,9 @@ var PatchApplicationService = class {
         continue;
       }
       try {
-        const absolutePath = path15.resolve(repositoryPath, targetFile);
-        if (existsSync2(absolutePath)) {
-          const stats = await fs16.stat(absolutePath);
+        const absolutePath = path18.resolve(repositoryPath, targetFile);
+        if (existsSync6(absolutePath)) {
+          const stats = await fs20.stat(absolutePath);
           const fileModTime = stats.mtime.getTime();
           if (fileModTime > scanStartTime) {
             logError(
@@ -18788,7 +18863,7 @@ var PatchApplicationService = class {
     const appliedFixes = [];
     const failedFixes = [];
     const skippedFixes = [];
-    const resolvedRepoPath = await fs16.realpath(repositoryPath);
+    const resolvedRepoPath = await fs20.realpath(repositoryPath);
     logInfo(
       `[${scanContext}] Starting patch application for ${fixes.length} fixes`,
       {
@@ -18936,11 +19011,11 @@ var PatchApplicationService = class {
   }) {
     const sanitizedRepoPath = String(repositoryPath || "").replace("\0", "").replace(/^(\.\.(\/|\\))+/, "");
     const sanitizedTargetFile = String(targetFile || "").replace("\0", "").replace(/^(\.\.(\/|\\))+/, "");
-    const absoluteFilePath = path15.resolve(
+    const absoluteFilePath = path18.resolve(
       sanitizedRepoPath,
       sanitizedTargetFile
     );
-    const relativePath = path15.relative(sanitizedRepoPath, absoluteFilePath);
+    const relativePath = path18.relative(sanitizedRepoPath, absoluteFilePath);
     if (relativePath.startsWith("..")) {
       throw new Error(
         `Security violation: target file ${targetFile} resolves outside repository`
@@ -18951,7 +19026,7 @@ var PatchApplicationService = class {
       targetFile: sanitizedTargetFile,
       absoluteFilePath,
       relativePath,
-      exists: existsSync2(absoluteFilePath)
+      exists: existsSync6(absoluteFilePath)
     });
     return { absoluteFilePath, relativePath };
   }
@@ -18974,7 +19049,7 @@ var PatchApplicationService = class {
       fix,
       scanContext
     });
-    appliedFiles.push(path15.relative(repositoryPath, actualPath));
+    appliedFiles.push(path18.relative(repositoryPath, actualPath));
     logDebug(`[${scanContext}] Created new file: ${relativePath}`);
   }
   /**
@@ -18986,7 +19061,7 @@ var PatchApplicationService = class {
     appliedFiles,
     scanContext
   }) {
-    if (existsSync2(absoluteFilePath)) {
+    if (existsSync6(absoluteFilePath)) {
       unlinkSync(absoluteFilePath);
       appliedFiles.push(relativePath);
       logDebug(`[${scanContext}] Deleted file: ${relativePath}`);
@@ -19005,12 +19080,12 @@ var PatchApplicationService = class {
     appliedFiles,
     scanContext
   }) {
-    if (!existsSync2(absoluteFilePath)) {
+    if (!existsSync6(absoluteFilePath)) {
       throw new Error(
         `Target file does not exist: ${targetFile} (resolved to: ${absoluteFilePath})`
       );
     }
-    const originalContent = readFileSync(absoluteFilePath, "utf8");
+    const originalContent = readFileSync3(absoluteFilePath, "utf8");
     const modifiedContent = this.applyHunksToFile(
       originalContent,
       fileDiff.chunks
@@ -19022,7 +19097,7 @@ var PatchApplicationService = class {
         fix,
         scanContext
       });
-      appliedFiles.push(path15.relative(repositoryPath, actualPath));
+      appliedFiles.push(path18.relative(repositoryPath, actualPath));
       logDebug(`[${scanContext}] Modified file: ${relativePath}`);
     }
   }
@@ -19217,8 +19292,8 @@ init_configs();
 
 // src/mcp/services/FileOperations.ts
 init_FileUtils();
-import fs17 from "fs";
-import path16 from "path";
+import fs21 from "fs";
+import path19 from "path";
 import AdmZip2 from "adm-zip";
 var FileOperations = class {
   /**
@@ -19238,10 +19313,10 @@ var FileOperations = class {
     let packedFilesCount = 0;
     const packedFiles = [];
     const excludedFiles = [];
-    const resolvedRepoPath = path16.resolve(repositoryPath);
+    const resolvedRepoPath = path19.resolve(repositoryPath);
     for (const filepath of fileList) {
-      const absoluteFilepath = path16.join(repositoryPath, filepath);
-      const resolvedFilePath = path16.resolve(absoluteFilepath);
+      const absoluteFilepath = path19.join(repositoryPath, filepath);
+      const resolvedFilePath = path19.resolve(absoluteFilepath);
       if (!resolvedFilePath.startsWith(resolvedRepoPath)) {
         const reason = "potential path traversal security risk";
         logDebug(`[FileOperations] Skipping ${filepath} due to ${reason}`);
@@ -19288,11 +19363,11 @@ var FileOperations = class {
     fileList,
     repositoryPath
   }) {
-    const resolvedRepoPath = path16.resolve(repositoryPath);
+    const resolvedRepoPath = path19.resolve(repositoryPath);
     const validatedPaths = [];
     for (const filepath of fileList) {
-      const absoluteFilepath = path16.join(repositoryPath, filepath);
-      const resolvedFilePath = path16.resolve(absoluteFilepath);
+      const absoluteFilepath = path19.join(repositoryPath, filepath);
+      const resolvedFilePath = path19.resolve(absoluteFilepath);
       if (!resolvedFilePath.startsWith(resolvedRepoPath)) {
         logDebug(
           `[FileOperations] Rejecting ${filepath} - path traversal attempt detected`
@@ -19300,7 +19375,7 @@ var FileOperations = class {
         continue;
       }
       try {
-        await fs17.promises.access(absoluteFilepath, fs17.constants.R_OK);
+        await fs21.promises.access(absoluteFilepath, fs21.constants.R_OK);
         validatedPaths.push(filepath);
       } catch (error) {
         logDebug(
@@ -19319,8 +19394,8 @@ var FileOperations = class {
     const fileDataArray = [];
     for (const absolutePath of filePaths) {
       try {
-        const content = await fs17.promises.readFile(absolutePath);
-        const relativePath = path16.basename(absolutePath);
+        const content = await fs21.promises.readFile(absolutePath);
+        const relativePath = path19.basename(absolutePath);
         fileDataArray.push({
           relativePath,
           absolutePath,
@@ -19345,7 +19420,7 @@ var FileOperations = class {
     relativeFilepath
   }) {
     try {
-      return await fs17.promises.readFile(absoluteFilepath);
+      return await fs21.promises.readFile(absoluteFilepath);
     } catch (fsError) {
       logError(
         `[FileOperations] Failed to read ${relativeFilepath} from filesystem: ${fsError}`
@@ -19632,14 +19707,14 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
    * since the last scan.
    */
   async scanForSecurityVulnerabilities({
-    path: path18,
+    path: path21,
     isAllDetectionRulesScan,
     isAllFilesScan,
     scanContext
   }) {
     this.hasAuthenticationFailed = false;
     logDebug(`[${scanContext}] Scanning for new security vulnerabilities`, {
-      path: path18
+      path: path21
     });
     if (!this.gqlClient) {
       logInfo(`[${scanContext}] No GQL client found, skipping scan`);
@@ -19655,11 +19730,11 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       logDebug(
         `[${scanContext}] Connected to the API, assembling list of files to scan`,
-        { path: path18 }
+        { path: path21 }
       );
       const isBackgroundScan = scanContext === ScanContext.BACKGROUND_INITIAL || scanContext === ScanContext.BACKGROUND_PERIODIC;
       const files = await getLocalFiles({
-        path: path18,
+        path: path21,
         isAllFilesScan,
         scanContext,
         scanRecentlyChangedFiles: !isBackgroundScan
@@ -19685,13 +19760,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
       const { fixReportId, projectId } = await scanFiles({
         fileList: filesToScan.map((file) => file.relativePath),
-        repositoryPath: path18,
+        repositoryPath: path21,
         gqlClient: this.gqlClient,
         isAllDetectionRulesScan,
         scanContext
       });
       logInfo(
-        `[${scanContext}] Security scan completed for ${path18} reportId: ${fixReportId} projectId: ${projectId}`
+        `[${scanContext}] Security scan completed for ${path21} reportId: ${fixReportId} projectId: ${projectId}`
       );
       if (isAllFilesScan) {
         return;
@@ -19985,13 +20060,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     });
     return scannedFiles.some((file) => file.relativePath === fixFile);
   }
-  async getFreshFixes({ path: path18 }) {
+  async getFreshFixes({ path: path21 }) {
     const scanContext = ScanContext.USER_REQUEST;
-    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path18 });
-    if (this.path !== path18) {
-      this.path = path18;
+    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path21 });
+    if (this.path !== path21) {
+      this.path = path21;
       this.reset();
-      logInfo(`[${scanContext}] Reset service state for new path`, { path: path18 });
+      logInfo(`[${scanContext}] Reset service state for new path`, { path: path21 });
     }
     try {
       this.gqlClient = await createAuthenticatedMcpGQLClient();
@@ -20009,7 +20084,7 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       throw error;
     }
-    this.triggerScan({ path: path18, gqlClient: this.gqlClient });
+    this.triggerScan({ path: path21, gqlClient: this.gqlClient });
     let isMvsAutoFixEnabled = null;
     try {
       isMvsAutoFixEnabled = await this.gqlClient.getMvsAutoFixSettings();
@@ -20043,33 +20118,33 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     return noFreshFixesPrompt;
   }
   triggerScan({
-    path: path18,
+    path: path21,
     gqlClient
   }) {
-    if (this.path !== path18) {
-      this.path = path18;
+    if (this.path !== path21) {
+      this.path = path21;
       this.reset();
-      logInfo(`Reset service state for new path in triggerScan`, { path: path18 });
+      logInfo(`Reset service state for new path in triggerScan`, { path: path21 });
     }
     this.gqlClient = gqlClient;
     if (!this.intervalId) {
-      this.startPeriodicScanning(path18);
-      this.executeInitialScan(path18);
-      void this.executeInitialFullScan(path18);
+      this.startPeriodicScanning(path21);
+      this.executeInitialScan(path21);
+      void this.executeInitialFullScan(path21);
     }
   }
-  startPeriodicScanning(path18) {
+  startPeriodicScanning(path21) {
     const scanContext = ScanContext.BACKGROUND_PERIODIC;
     logDebug(
       `[${scanContext}] Starting periodic scan for new security vulnerabilities`,
       {
-        path: path18
+        path: path21
       }
     );
     this.intervalId = setInterval(() => {
-      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path18 });
+      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path21 });
       this.scanForSecurityVulnerabilities({
-        path: path18,
+        path: path21,
         scanContext
       }).catch((error) => {
         logError(`[${scanContext}] Error during periodic security scan`, {
@@ -20078,45 +20153,45 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
     }, MCP_PERIODIC_CHECK_INTERVAL);
   }
-  async executeInitialFullScan(path18) {
+  async executeInitialFullScan(path21) {
     const scanContext = ScanContext.FULL_SCAN;
-    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path18 });
+    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path21 });
     logDebug(`[${scanContext}] Full scan paths scanned`, {
       fullScanPathsScanned: this.fullScanPathsScanned
     });
-    if (this.fullScanPathsScanned.includes(path18)) {
+    if (this.fullScanPathsScanned.includes(path21)) {
       logDebug(`[${scanContext}] Full scan already executed for this path`, {
-        path: path18
+        path: path21
       });
       return;
     }
     configStore.set("fullScanPathsScanned", [
       ...this.fullScanPathsScanned,
-      path18
+      path21
     ]);
     try {
       await this.scanForSecurityVulnerabilities({
-        path: path18,
+        path: path21,
         isAllFilesScan: true,
         isAllDetectionRulesScan: true,
         scanContext: ScanContext.FULL_SCAN
       });
-      if (!this.fullScanPathsScanned.includes(path18)) {
-        this.fullScanPathsScanned.push(path18);
+      if (!this.fullScanPathsScanned.includes(path21)) {
+        this.fullScanPathsScanned.push(path21);
         configStore.set("fullScanPathsScanned", this.fullScanPathsScanned);
       }
-      logInfo(`[${scanContext}] Full scan completed`, { path: path18 });
+      logInfo(`[${scanContext}] Full scan completed`, { path: path21 });
     } catch (error) {
       logError(`[${scanContext}] Error during initial full security scan`, {
         error
       });
     }
   }
-  executeInitialScan(path18) {
+  executeInitialScan(path21) {
     const scanContext = ScanContext.BACKGROUND_INITIAL;
-    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path18 });
+    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path21 });
     this.scanForSecurityVulnerabilities({
-      path: path18,
+      path: path21,
       scanContext: ScanContext.BACKGROUND_INITIAL
     }).catch((error) => {
       logError(`[${scanContext}] Error during initial security scan`, { error });
@@ -20213,9 +20288,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path18 = pathValidationResult.path;
+    const path21 = pathValidationResult.path;
     const resultText = await this.newFixesService.getFreshFixes({
-      path: path18
+      path: path21
     });
     logInfo("CheckForNewAvailableFixesTool execution completed", {
       resultText
@@ -20392,8 +20467,8 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path18 = pathValidationResult.path;
-    const gitService = new GitService(path18, log);
+    const path21 = pathValidationResult.path;
+    const gitService = new GitService(path21, log);
     const gitValidation = await gitService.validateRepository();
     if (!gitValidation.isValid) {
       throw new Error(`Invalid git repository: ${gitValidation.error}`);
@@ -20781,9 +20856,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path18 = pathValidationResult.path;
+    const path21 = pathValidationResult.path;
     const files = await getLocalFiles({
-      path: path18,
+      path: path21,
       maxFileSize: MCP_MAX_FILE_SIZE,
       maxFiles: args.maxFiles,
       scanContext: ScanContext.USER_REQUEST,
@@ -20803,7 +20878,7 @@ Example payload:
     try {
       const fixResult = await this.vulnerabilityFixService.processVulnerabilities({
         fileList: files.map((file) => file.relativePath),
-        repositoryPath: path18,
+        repositoryPath: path21,
         offset: args.offset,
         limit: args.limit,
         isRescan: args.rescan || !!args.maxFiles
@@ -20907,7 +20982,7 @@ var mcpHandler = async (_args) => {
 };
 
 // src/args/commands/review.ts
-import fs18 from "fs";
+import fs22 from "fs";
 import chalk9 from "chalk";
 function reviewBuilder(yargs2) {
   return yargs2.option("f", {
@@ -20944,7 +21019,7 @@ function reviewBuilder(yargs2) {
   ).help();
 }
 function validateReviewOptions(argv) {
-  if (!fs18.existsSync(argv.f)) {
+  if (!fs22.existsSync(argv.f)) {
     throw new CliError(`
 Can't access ${chalk9.bold(argv.f)}`);
   }
@@ -21018,7 +21093,7 @@ async function addScmTokenHandler(args) {
 
 // src/args/commands/upload_ai_blame.ts
 import fsPromises3 from "fs/promises";
-import path17 from "path";
+import path20 from "path";
 import chalk10 from "chalk";
 import Configstore6 from "configstore";
 import { withFile } from "tmp-promise";
@@ -21073,6 +21148,13 @@ function uploadAiBlameBuilder(args) {
     type: "string",
     array: true,
     describe: chalk10.bold("Tool/IDE name(s) (optional, one per session)")
+  }).option("blame-type", {
+    type: "string",
+    array: true,
+    choices: Object.values(AiBlameInferenceType),
+    describe: chalk10.bold(
+      "Blame type(s) (optional, one per session, defaults to CHAT)"
+    )
   }).strict();
 }
 var config5 = new Configstore6(packageJson.name, { apiToken: "" });
@@ -21093,6 +21175,7 @@ async function uploadAiBlameHandler(args, exitOnError = true) {
   const models = args.model || [];
   const tools = args.toolName || args["tool-name"] || [];
   const responseTimes = args.aiResponseAt || args["ai-response-at"] || [];
+  const blameTypes = args.blameType || args["blame-type"] || [];
   if (prompts.length !== inferences.length) {
     const errorMsg = "prompt and inference must have the same number of entries";
     console.error(chalk10.red(errorMsg));
@@ -21120,11 +21203,12 @@ async function uploadAiBlameHandler(args, exitOnError = true) {
       throw new Error(errorMsg);
     }
     sessions.push({
-      promptFileName: path17.basename(promptPath),
-      inferenceFileName: path17.basename(inferencePath),
+      promptFileName: path20.basename(promptPath),
+      inferenceFileName: path20.basename(inferencePath),
       aiResponseAt: responseTimes[i] || nowIso,
       model: models[i],
-      toolName: tools[i]
+      toolName: tools[i],
+      blameType: blameTypes[i] || "CHAT" /* Chat */
     });
   }
   const authenticatedClient = await getAuthenticatedGQLClientForIdeExtension();
@@ -21144,18 +21228,22 @@ async function uploadAiBlameHandler(args, exitOnError = true) {
     const us = uploadSessions[i];
     const promptPath = String(prompts[i]);
     const inferencePath = String(inferences[i]);
-    await uploadFile({
-      file: promptPath,
-      url: us.prompt.url,
-      uploadFields: JSON.parse(us.prompt.uploadFieldsJSON),
-      uploadKey: us.prompt.uploadKey
-    });
-    await uploadFile({
-      file: inferencePath,
-      url: us.inference.url,
-      uploadFields: JSON.parse(us.inference.uploadFieldsJSON),
-      uploadKey: us.inference.uploadKey
-    });
+    await Promise.all([
+      // Prompt
+      uploadFile({
+        file: promptPath,
+        url: us.prompt.url,
+        uploadFields: JSON.parse(us.prompt.uploadFieldsJSON),
+        uploadKey: us.prompt.uploadKey
+      }),
+      // Inference
+      uploadFile({
+        file: inferencePath,
+        url: us.inference.url,
+        uploadFields: JSON.parse(us.inference.uploadFieldsJSON),
+        uploadKey: us.inference.uploadKey
+      })
+    ]);
   }
   const finalizeSessions = uploadSessions.map((us, i) => {
     const s = sessions[i];
@@ -21165,7 +21253,8 @@ async function uploadAiBlameHandler(args, exitOnError = true) {
       inferenceKey: us.inference.uploadKey,
       aiResponseAt: s.aiResponseAt,
       model: s.model,
-      toolName: s.toolName
+      toolName: s.toolName,
+      blameType: s.blameType
     };
   });
   const finRes = await authenticatedClient.finalizeAIBlameInferencesUploadRaw({