mobbdev 1.2.50 → 1.2.52

package/dist/index.mjs

@@ -4170,6 +4170,9 @@ import multimatch from "multimatch";
 import StreamZip from "node-stream-zip";
 import tmp from "tmp";
 
+// src/features/analysis/scm/ado/ado.ts
+import pLimit from "p-limit";
+
 // src/features/analysis/scm/errors.ts
 var InvalidAccessTokenError = class extends Error {
   constructor(m, scmType) {
@@ -7043,7 +7046,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 path26 = [
+      const path27 = [
         prefixPath,
         owner,
         projectName,
@@ -7054,7 +7057,7 @@ async function getAdoSdk(params) {
         "items",
         "items"
       ].filter(Boolean).join("/");
-      return new URL(`${path26}?${params2}`, origin2).toString();
+      return new URL(`${path27}?${params2}`, origin2).toString();
     },
     async getAdoBranchList({ repoUrl }) {
       try {
@@ -7094,6 +7097,136 @@ async function getAdoSdk(params) {
       );
       return res.pullRequestId;
     },
+    async getAdoPullRequestMetadata({
+      repoUrl,
+      prNumber
+    }) {
+      const { repo, projectName } = parseAdoOwnerAndRepo(repoUrl);
+      const git = await api2.getGitApi();
+      const pr = await git.getPullRequest(repo, prNumber, projectName);
+      if (!pr) {
+        throw new Error(`Pull request #${prNumber} not found`);
+      }
+      return {
+        title: pr.title,
+        targetBranch: (pr.targetRefName || "").replace("refs/heads/", ""),
+        sourceBranch: (pr.sourceRefName || "").replace("refs/heads/", ""),
+        headCommitSha: pr.lastMergeSourceCommit?.commitId || pr.lastMergeCommit?.commitId || ""
+      };
+    },
+    async getAdoPrFiles({
+      repoUrl,
+      prNumber
+    }) {
+      const { repo, projectName } = parseAdoOwnerAndRepo(repoUrl);
+      const git = await api2.getGitApi();
+      const iterations = await git.getPullRequestIterations(
+        repo,
+        prNumber,
+        projectName
+      );
+      if (!iterations || iterations.length === 0) {
+        return [];
+      }
+      const lastIteration = iterations[iterations.length - 1];
+      if (!lastIteration?.id) {
+        return [];
+      }
+      const iterationId = lastIteration.id;
+      const changes = await git.getPullRequestIterationChanges(
+        repo,
+        prNumber,
+        iterationId,
+        projectName
+      );
+      if (!changes?.changeEntries) {
+        return [];
+      }
+      return changes.changeEntries.filter((entry) => {
+        const changeType = entry.changeType;
+        return changeType !== 16 && entry.item?.path;
+      }).map((entry) => {
+        const path27 = entry.item.path;
+        return path27.startsWith("/") ? path27.slice(1) : path27;
+      });
+    },
+    async searchAdoPullRequests({
+      repoUrl,
+      status,
+      skip,
+      top
+    }) {
+      const { repo, projectName } = parseAdoOwnerAndRepo(repoUrl);
+      const git = await api2.getGitApi();
+      const searchCriteria = {
+        // Cast to number to avoid TypeScript enum compatibility issues between
+        // our AdoPullRequestStatus and azure-devops-node-api's PullRequestStatus
+        status: status ?? 4 /* All */
+      };
+      const prs = await git.getPullRequests(
+        repo,
+        searchCriteria,
+        projectName,
+        void 0,
+        // maxCommentLength
+        skip,
+        top
+      );
+      return prs;
+    },
+    async getAdoPullRequestMetrics({
+      repoUrl,
+      prNumber
+    }) {
+      const { repo, projectName } = parseAdoOwnerAndRepo(repoUrl);
+      const git = await api2.getGitApi();
+      const pr = await git.getPullRequest(repo, prNumber, projectName);
+      if (!pr) {
+        throw new Error(`Pull request #${prNumber} not found`);
+      }
+      const threads = await git.getThreads(repo, prNumber, projectName);
+      const commentIds = (threads || []).filter((t) => t.id && t.comments && t.comments.length > 0).map((t) => String(t.id));
+      return {
+        pr,
+        commentIds,
+        linesAdded: 0
+      };
+    },
+    async getAdoRecentCommits({
+      repoUrl,
+      since
+    }) {
+      const { repo, projectName } = parseAdoOwnerAndRepo(repoUrl);
+      const git = await api2.getGitApi();
+      const repository = await git.getRepository(
+        decodeURI(repo),
+        projectName ? decodeURI(projectName) : void 0
+      );
+      const defaultBranch = repository.defaultBranch?.replace("refs/heads/", "");
+      const commits = await git.getCommits(
+        repo,
+        {
+          fromDate: since,
+          itemVersion: defaultBranch ? { version: defaultBranch } : void 0,
+          $top: 100
+        },
+        projectName
+      );
+      return commits;
+    },
+    async getAdoPrCommits({
+      repoUrl,
+      prNumber
+    }) {
+      const { repo, projectName } = parseAdoOwnerAndRepo(repoUrl);
+      const git = await api2.getGitApi();
+      const commits = await git.getPullRequestCommits(
+        repo,
+        prNumber,
+        projectName
+      );
+      return (commits || []).filter((c) => c.commitId).map((c) => c.commitId);
+    },
     async getAdoRepoDefaultBranch({
       repoUrl
     }) {
@@ -7232,28 +7365,38 @@ async function getAdoRepoList({
       });
       const gitOrg = await orgApi.getGitApi();
       const orgRepos = await gitOrg.getRepositories();
+      const repoLimit = pLimit(5);
       const repoInfoList = (await Promise.allSettled(
-        orgRepos.map(async (repo) => {
-          if (!repo.name || !repo.remoteUrl || !repo.defaultBranch) {
-            throw new InvalidRepoUrlError("bad repo");
-          }
-          const branch = await gitOrg.getBranch(
-            repo.name,
-            repo.defaultBranch.replace(/^refs\/heads\//, ""),
-            repo.project?.name
-          );
-          return {
-            repoName: repo.name,
-            repoUrl: repo.remoteUrl.replace(
-              /^[hH][tT][tT][pP][sS]:\/\/[^/]+@/,
-              "https://"
-            ),
-            repoOwner: org,
-            repoIsPublic: repo.project?.visibility === 2 /* Public */,
-            repoLanguages: [],
-            repoUpdatedAt: branch.commit?.committer?.date?.toDateString() || repo.project?.lastUpdateTime?.toDateString() || (/* @__PURE__ */ new Date()).toDateString()
-          };
-        })
+        orgRepos.map(
+          (repo) => repoLimit(async () => {
+            if (!repo.name || !repo.remoteUrl || !repo.defaultBranch) {
+              throw new InvalidRepoUrlError("bad repo");
+            }
+            const branch = await gitOrg.getBranch(
+              repo.name,
+              repo.defaultBranch.replace(/^refs\/heads\//, ""),
+              repo.project?.name
+            );
+            return {
+              repoName: repo.name,
+              repoUrl: repo.remoteUrl.replace(
+                /^[hH][tT][tT][pP][sS]:\/\/[^/]+@/,
+                "https://"
+              ),
+              repoOwner: org,
+              repoIsPublic: repo.project?.visibility === 2 /* Public */,
+              repoLanguages: [],
+              repoUpdatedAt: (
+                // Use the latest available timestamp.
+                // branch.commit.committer.date = last commit on default branch.
+                // project.lastUpdateTime = last project-level change (may be stale).
+                // ADO doesn't expose a per-repo "last pushed" date like GitHub does,
+                // so feature branch pushes won't be reflected until merged.
+                branch.commit?.committer?.date?.toISOString() || repo.project?.lastUpdateTime?.toISOString() || (/* @__PURE__ */ new Date()).toISOString()
+              )
+            };
+          })
+        )
       )).reduce((acc, res) => {
         if (res.status === "fulfilled") {
           acc.push(res.value);
@@ -7273,6 +7416,8 @@ async function getAdoRepoList({
 
 // src/features/analysis/scm/ado/AdoSCMLib.ts
 import { setTimeout as setTimeout2 } from "timers/promises";
+import pLimit2 from "p-limit";
+init_client_generates();
 
 // src/features/analysis/scm/scmSubmit/index.ts
 init_GitService();
@@ -7407,6 +7552,19 @@ var SCMLib = class {
   }
 };
 
+// src/features/analysis/scm/utils/cursorValidation.ts
+var MAX_CURSOR_VALUE = 1e5;
+function parseCursorSafe(cursor, defaultValue = 0, maxValue = MAX_CURSOR_VALUE) {
+  if (cursor === null || cursor === void 0 || cursor === "") {
+    return defaultValue;
+  }
+  const parsed = parseInt(cursor, 10);
+  if (isNaN(parsed) || parsed < 0 || parsed > maxValue) {
+    return defaultValue;
+  }
+  return parsed;
+}
+
 // src/features/analysis/scm/ado/AdoSCMLib.ts
 async function initAdoSdk(params) {
   const { url, accessToken, scmOrg } = params;
@@ -7599,28 +7757,190 @@ var AdoSCMLib = class extends SCMLib {
       markdownComment: comment
     });
   }
-  async getSubmitRequestMetadata(_submitRequestId) {
-    throw new Error("getSubmitRequestMetadata not implemented for ADO");
+  async getSubmitRequestMetadata(submitRequestId) {
+    this._validateAccessTokenAndUrl();
+    const adoSdk = await this.getAdoSdk();
+    return adoSdk.getAdoPullRequestMetadata({
+      repoUrl: this.url,
+      prNumber: Number(submitRequestId)
+    });
   }
-  async getPrFiles(_prNumber) {
-    throw new Error("getPrFiles not implemented for ADO");
+  async getPrFiles(prNumber) {
+    this._validateAccessTokenAndUrl();
+    const adoSdk = await this.getAdoSdk();
+    return adoSdk.getAdoPrFiles({
+      repoUrl: this.url,
+      prNumber
+    });
   }
-  async searchSubmitRequests(_params) {
-    throw new Error("searchSubmitRequests not implemented for ADO");
+  async searchSubmitRequests(params) {
+    this._validateAccessToken();
+    const adoSdk = await this.getAdoSdk();
+    const skip = parseCursorSafe(params.cursor, 0);
+    const top = params.limit || 10;
+    let status = 4 /* All */;
+    if (params.filters?.state === "open") {
+      status = 1 /* Active */;
+    } else if (params.filters?.state === "closed") {
+      status = 4 /* All */;
+    }
+    const prs = await adoSdk.searchAdoPullRequests({
+      repoUrl: params.repoUrl,
+      status,
+      skip,
+      top: top + 1
+      // Fetch one extra to determine hasMore
+    });
+    const apiHasMore = prs.length > top;
+    const prsPage = prs.slice(0, top);
+    const getAdoPrUpdatedDate = (pr) => pr.closedDate || pr.lastMergeSourceCommit?.committer?.date || pr.creationDate || /* @__PURE__ */ new Date();
+    let filtered = prsPage;
+    if (params.filters?.updatedAfter) {
+      const afterDate = params.filters.updatedAfter;
+      filtered = prsPage.filter((pr) => getAdoPrUpdatedDate(pr) > afterDate);
+    }
+    if (params.filters?.state === "closed") {
+      filtered = filtered.filter(
+        (pr) => pr.status === 3 /* Completed */ || pr.status === 2 /* Abandoned */
+      );
+    }
+    const results = filtered.map((pr) => {
+      let prStatus = "open";
+      if (pr.status === 3 /* Completed */) {
+        prStatus = "merged";
+      } else if (pr.status === 2 /* Abandoned */) {
+        prStatus = "closed";
+      }
+      return {
+        submitRequestId: String(pr.pullRequestId),
+        submitRequestNumber: pr.pullRequestId || 0,
+        title: pr.title || "",
+        status: prStatus,
+        sourceBranch: (pr.sourceRefName || "").replace("refs/heads/", ""),
+        targetBranch: (pr.targetRefName || "").replace("refs/heads/", ""),
+        authorName: pr.createdBy?.displayName,
+        authorEmail: pr.createdBy?.uniqueName,
+        createdAt: pr.creationDate || /* @__PURE__ */ new Date(),
+        updatedAt: getAdoPrUpdatedDate(pr),
+        description: pr.description,
+        tickets: [],
+        changedLines: { added: 0, removed: 0 }
+      };
+    });
+    return {
+      results,
+      nextCursor: apiHasMore ? String(skip + top) : void 0,
+      hasMore: apiHasMore
+    };
   }
-  async searchRepos(_params) {
-    throw new Error("searchRepos not implemented for ADO");
+  // TODO: Performance — this fetches ALL repositories on every call, then paginates
+  // in-memory. For orgs with thousands of repos this can be slow and wasteful,
+  // especially when the UI pages through results (each page triggers a full re-fetch).
+  // Consider caching the fetched list with a short TTL, or using ADO's
+  // getRepositoriesPaged() API per-project for true server-side pagination.
+  async searchRepos(params) {
+    this._validateAccessToken();
+    if (this.url && new URL(this.url).origin !== scmCloudUrl.Ado) {
+      throw new Error(
+        `Oauth token is not supported for ADO on prem - ${this.url}`
+      );
+    }
+    const allRepos = await getAdoRepoList({
+      orgName: params.scmOrg,
+      accessToken: this.accessToken,
+      tokenOrg: this.scmOrg
+    });
+    allRepos.sort((a, b) => {
+      const dateA = a.repoUpdatedAt ? new Date(a.repoUpdatedAt).getTime() : 0;
+      const dateB = b.repoUpdatedAt ? new Date(b.repoUpdatedAt).getTime() : 0;
+      return dateB - dateA;
+    });
+    const page = parseCursorSafe(params.cursor, 0);
+    const limit = params.limit || 100;
+    const start = page;
+    const pageResults = allRepos.slice(start, start + limit);
+    const hasMore = start + limit < allRepos.length;
+    return {
+      results: pageResults,
+      nextCursor: hasMore ? String(start + limit) : void 0,
+      hasMore
+    };
   }
-  // TODO: Add comprehensive tests for getPullRequestMetrics (ADO)
-  // 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 ADO");
+  async getPrCommitsBatch(repoUrl, prNumbers) {
+    this._validateAccessToken();
+    const adoSdk = await this.getAdoSdk();
+    const result = /* @__PURE__ */ new Map();
+    const limit = pLimit2(5);
+    await Promise.all(
+      prNumbers.map(
+        (prNumber) => limit(async () => {
+          try {
+            const commits = await adoSdk.getAdoPrCommits({
+              repoUrl,
+              prNumber
+            });
+            result.set(prNumber, commits);
+          } catch (error) {
+            console.warn(
+              `[AdoSCMLib.getPrCommitsBatch] Failed to fetch commits for PR #${prNumber}:`,
+              error instanceof Error ? error.message : String(error)
+            );
+            result.set(prNumber, []);
+          }
+        })
+      )
+    );
+    return result;
   }
-  async getRecentCommits(_since) {
-    throw new Error("getRecentCommits not implemented for ADO");
+  async getPullRequestMetrics(prNumber) {
+    this._validateAccessTokenAndUrl();
+    const adoSdk = await this.getAdoSdk();
+    const { pr, commentIds, linesAdded } = await adoSdk.getAdoPullRequestMetrics({
+      repoUrl: this.url,
+      prNumber
+    });
+    let prStatus = "ACTIVE" /* Active */;
+    if (pr.status === 3) {
+      prStatus = "MERGED" /* Merged */;
+    } else if (pr.status === 2) {
+      prStatus = "CLOSED" /* Closed */;
+    } else if (pr.isDraft) {
+      prStatus = "DRAFT" /* Draft */;
+    }
+    return {
+      prId: String(prNumber),
+      repositoryUrl: this.url,
+      prCreatedAt: pr.creationDate || /* @__PURE__ */ new Date(),
+      prMergedAt: pr.closedDate && pr.status === 3 ? pr.closedDate : null,
+      linesAdded,
+      prStatus,
+      commentIds
+    };
+  }
+  async getRecentCommits(since) {
+    this._validateAccessTokenAndUrl();
+    const adoSdk = await this.getAdoSdk();
+    const commits = await adoSdk.getAdoRecentCommits({
+      repoUrl: this.url,
+      since
+    });
+    return {
+      data: commits.map((c) => ({
+        sha: c.commitId || "",
+        commit: {
+          committer: c.committer?.date ? { date: c.committer.date.toISOString() } : void 0,
+          author: c.author ? { email: c.author.email, name: c.author.name } : void 0,
+          message: c.comment
+        },
+        parents: c.parents?.map((sha) => ({ sha }))
+      }))
+    };
   }
   async getRateLimitStatus() {
-    return null;
+    return {
+      remaining: 1e4,
+      reset: new Date(Date.now() + 36e5)
+    };
   }
 };
 
@@ -8218,19 +8538,6 @@ init_env();
 import { z as z22 } from "zod";
 init_client_generates();
 
-// src/features/analysis/scm/utils/cursorValidation.ts
-var MAX_CURSOR_VALUE = 1e5;
-function parseCursorSafe(cursor, defaultValue = 0, maxValue = MAX_CURSOR_VALUE) {
-  if (cursor === null || cursor === void 0 || cursor === "") {
-    return defaultValue;
-  }
-  const parsed = parseInt(cursor, 10);
-  if (isNaN(parsed) || parsed < 0 || parsed > maxValue) {
-    return defaultValue;
-  }
-  return parsed;
-}
-
 // src/features/analysis/scm/github/github.ts
 import { RequestError } from "@octokit/request-error";
 
@@ -9597,7 +9904,7 @@ import {
   Gitlab
 } from "@gitbeaker/rest";
 import Debug3 from "debug";
-import pLimit from "p-limit";
+import pLimit3 from "p-limit";
 import {
   Agent,
   fetch as undiciFetch,
@@ -10026,7 +10333,7 @@ async function getGitlabMrCommitsBatch({
     url: repoUrl,
     gitlabAuthToken: accessToken
   });
-  const limit = pLimit(GITLAB_API_CONCURRENCY);
+  const limit = pLimit3(GITLAB_API_CONCURRENCY);
   const results = await Promise.all(
     mrNumbers.map(
       (mrNumber) => limit(async () => {
@@ -10065,7 +10372,7 @@ async function getGitlabMrDataBatch({
     url: repoUrl,
     gitlabAuthToken: accessToken
   });
-  const limit = pLimit(GITLAB_API_CONCURRENCY);
+  const limit = pLimit3(GITLAB_API_CONCURRENCY);
   const results = await Promise.all(
     mrNumbers.map(
       (mrNumber) => limit(async () => {
@@ -13060,7 +13367,7 @@ async function getRepositoryUrl() {
     }
     const remoteUrl = await gitService.getRemoteUrl();
     const parsed = parseScmURL(remoteUrl);
-    return parsed?.scmType === "GitHub" /* GitHub */ || parsed?.scmType === "GitLab" /* GitLab */ ? remoteUrl : null;
+    return parsed?.scmType && parsed.scmType !== "Unknown" ? remoteUrl : null;
   } catch {
     return null;
   }
@@ -13867,7 +14174,7 @@ async function postIssueComment(params) {
     fpDescription
   } = params;
   const {
-    path: path26,
+    path: path27,
     startLine,
     vulnerabilityReportIssue: {
       vulnerabilityReportIssueTags,
@@ -13882,7 +14189,7 @@ async function postIssueComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path26,
+    path: path27,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -13916,7 +14223,7 @@ async function postFixComment(params) {
     scanner
   } = params;
   const {
-    path: path26,
+    path: path27,
     startLine,
     vulnerabilityReportIssue: { fixId, vulnerabilityReportIssueTags, category },
     vulnerabilityReportIssueId
@@ -13934,7 +14241,7 @@ async function postFixComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path26,
+    path: path27,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -15857,6 +16164,47 @@ init_client_generates();
 init_GitService();
 init_urlParser2();
 
+// src/utils/computeGitDiffAdditions.ts
+import { mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import path13 from "path";
+import { simpleGit as simpleGit4 } from "simple-git";
+async function computeGitDiffAdditions(oldStr, newStr) {
+  const tmpDir = await mkdtemp(path13.join(tmpdir(), "diff-"));
+  const oldFile = path13.join(tmpDir, "old");
+  const newFile = path13.join(tmpDir, "new");
+  try {
+    await writeFile(oldFile, oldStr);
+    await writeFile(newFile, newStr);
+    const git = simpleGit4();
+    let result;
+    try {
+      result = await git.raw([
+        "diff",
+        "--no-index",
+        "--unified=0",
+        oldFile,
+        newFile
+      ]);
+    } catch (err) {
+      if (err instanceof Error && "stdOut" in err) {
+        result = err.stdOut;
+      } else {
+        throw err;
+      }
+    }
+    const additions = [];
+    for (const line of result.split("\n")) {
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        additions.push(line.slice(1));
+      }
+    }
+    return additions.join("\n");
+  } finally {
+    await rm(tmpDir, { recursive: true, force: true });
+  }
+}
+
 // src/features/claude_code/transcript_parser.ts
 import fsPromises4 from "fs/promises";
 function processTranscriptLine(entry) {
@@ -16041,29 +16389,40 @@ async function readStdinData() {
 function validateHookData(data) {
   return HookDataSchema.parse(data);
 }
-function extractInference(hookData) {
+function extractStructuredPatchAdditions(hookData) {
+  const editResponse = hookData.tool_response;
+  const additions = [];
+  for (const patch of editResponse.structuredPatch) {
+    for (const line of patch.lines) {
+      if (line.startsWith("+")) {
+        additions.push(line.slice(1));
+      }
+    }
+  }
+  return additions.join("\n");
+}
+async function extractInference(hookData) {
   if (hookData.tool_name === "Write") {
     const writeInput = hookData.tool_input;
     return writeInput.content || "";
   }
   if (hookData.tool_name === "Edit") {
-    const editResponse = hookData.tool_response;
-    const additions = [];
-    for (const patch of editResponse.structuredPatch) {
-      for (const line of patch.lines) {
-        if (line.startsWith("+")) {
-          additions.push(line.slice(1));
-        }
-      }
+    const editInput = hookData.tool_input;
+    try {
+      return await computeGitDiffAdditions(
+        editInput.old_string,
+        editInput.new_string
+      );
+    } catch {
+      return extractStructuredPatchAdditions(hookData);
     }
-    return additions.join("\n");
   }
   return "";
 }
 async function collectHookData() {
   const rawData = await readStdinData();
   const hookData = validateHookData(rawData);
-  const inference = extractInference(hookData);
+  const inference = await extractInference(hookData);
   let tracePayload;
   try {
     tracePayload = await parseTranscriptAndCreateTrace(
@@ -16148,9 +16507,9 @@ async function processAndUploadHookData() {
 // src/features/claude_code/install_hook.ts
 import fsPromises5 from "fs/promises";
 import os4 from "os";
-import path13 from "path";
+import path14 from "path";
 import chalk11 from "chalk";
-var CLAUDE_SETTINGS_PATH = path13.join(os4.homedir(), ".claude", "settings.json");
+var CLAUDE_SETTINGS_PATH = path14.join(os4.homedir(), ".claude", "settings.json");
 async function claudeSettingsExists() {
   try {
     await fsPromises5.access(CLAUDE_SETTINGS_PATH);
@@ -16335,8 +16694,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(path26) {
-    this.knownWorkspacePath = path26;
+  static setKnownWorkspacePath(path27) {
+    this.knownWorkspacePath = path27;
   }
   /**
    * Gets the known workspace path that was previously validated
@@ -17197,7 +17556,7 @@ async function createAuthenticatedMcpGQLClient({
 import { execSync as execSync2 } from "child_process";
 import fs13 from "fs";
 import os5 from "os";
-import path14 from "path";
+import path15 from "path";
 var IDEs = ["cursor", "windsurf", "webstorm", "vscode", "claude"];
 var runCommand = (cmd) => {
   try {
@@ -17212,7 +17571,7 @@ var gitInfo = {
 };
 var getClaudeWorkspacePaths = () => {
   const home = os5.homedir();
-  const claudeIdePath = path14.join(home, ".claude", "ide");
+  const claudeIdePath = path15.join(home, ".claude", "ide");
   const workspacePaths = [];
   if (!fs13.existsSync(claudeIdePath)) {
     return workspacePaths;
@@ -17220,7 +17579,7 @@ var getClaudeWorkspacePaths = () => {
   try {
     const lockFiles = fs13.readdirSync(claudeIdePath).filter((file) => file.endsWith(".lock"));
     for (const lockFile of lockFiles) {
-      const lockFilePath = path14.join(claudeIdePath, lockFile);
+      const lockFilePath = path15.join(claudeIdePath, lockFile);
       try {
         const lockContent = JSON.parse(fs13.readFileSync(lockFilePath, "utf8"));
         if (lockContent.workspaceFolders && Array.isArray(lockContent.workspaceFolders)) {
@@ -17245,24 +17604,24 @@ var getMCPConfigPaths = (hostName) => {
   switch (hostName.toLowerCase()) {
     case "cursor":
       return [
-        path14.join(currentDir, ".cursor", "mcp.json"),
+        path15.join(currentDir, ".cursor", "mcp.json"),
         // local first
-        path14.join(home, ".cursor", "mcp.json")
+        path15.join(home, ".cursor", "mcp.json")
       ];
     case "windsurf":
       return [
-        path14.join(currentDir, ".codeium", "mcp_config.json"),
+        path15.join(currentDir, ".codeium", "mcp_config.json"),
         // local first
-        path14.join(home, ".codeium", "windsurf", "mcp_config.json")
+        path15.join(home, ".codeium", "windsurf", "mcp_config.json")
       ];
     case "webstorm":
       return [];
     case "visualstudiocode":
     case "vscode":
       return [
-        path14.join(currentDir, ".vscode", "mcp.json"),
+        path15.join(currentDir, ".vscode", "mcp.json"),
         // local first
-        process.platform === "win32" ? path14.join(home, "AppData", "Roaming", "Code", "User", "mcp.json") : path14.join(
+        process.platform === "win32" ? path15.join(home, "AppData", "Roaming", "Code", "User", "mcp.json") : path15.join(
           home,
           "Library",
           "Application Support",
@@ -17273,13 +17632,13 @@ var getMCPConfigPaths = (hostName) => {
       ];
     case "claude": {
       const claudePaths = [
-        path14.join(currentDir, ".claude.json"),
+        path15.join(currentDir, ".claude.json"),
         // local first
-        path14.join(home, ".claude.json")
+        path15.join(home, ".claude.json")
       ];
       const workspacePaths = getClaudeWorkspacePaths();
       for (const workspacePath of workspacePaths) {
-        claudePaths.push(path14.join(workspacePath, ".mcp.json"));
+        claudePaths.push(path15.join(workspacePath, ".mcp.json"));
       }
       return claudePaths;
     }
@@ -17440,10 +17799,10 @@ var getHostInfo = (additionalMcpList) => {
   const ideConfigPaths = /* @__PURE__ */ new Set();
   for (const ide of IDEs) {
     const configPaths = getMCPConfigPaths(ide);
-    configPaths.forEach((path26) => ideConfigPaths.add(path26));
+    configPaths.forEach((path27) => ideConfigPaths.add(path27));
   }
   const uniqueAdditionalPaths = additionalMcpList.filter(
-    (path26) => !ideConfigPaths.has(path26)
+    (path27) => !ideConfigPaths.has(path27)
   );
   for (const ide of IDEs) {
     const cfg = readMCPConfig(ide);
@@ -17565,7 +17924,7 @@ init_configs();
 init_configs();
 import fs14 from "fs";
 import os6 from "os";
-import path15 from "path";
+import path16 from "path";
 var MAX_DEPTH = 2;
 var patterns = ["mcp", "claude"];
 var isFileMatch = (fileName) => {
@@ -17585,7 +17944,7 @@ var searchDir = async (dir, depth = 0) => {
   if (depth > MAX_DEPTH) return results;
   const entries = await fs14.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
-    const fullPath = path15.join(dir, entry.name);
+    const fullPath = path16.join(dir, entry.name);
     if (entry.isFile() && isFileMatch(entry.name)) {
       results.push(fullPath);
     } else if (entry.isDirectory()) {
@@ -17602,14 +17961,14 @@ var findSystemMCPConfigs = async () => {
     const home = os6.homedir();
     const platform2 = os6.platform();
     const knownDirs = platform2 === "win32" ? [
-      path15.join(home, ".cursor"),
-      path15.join(home, "Documents"),
-      path15.join(home, "Downloads")
+      path16.join(home, ".cursor"),
+      path16.join(home, "Documents"),
+      path16.join(home, "Downloads")
     ] : [
-      path15.join(home, ".cursor"),
-      process.env["XDG_CONFIG_HOME"] || path15.join(home, ".config"),
-      path15.join(home, "Documents"),
-      path15.join(home, "Downloads")
+      path16.join(home, ".cursor"),
+      process.env["XDG_CONFIG_HOME"] || path16.join(home, ".config"),
+      path16.join(home, "Documents"),
+      path16.join(home, "Downloads")
     ];
     const timeoutPromise = new Promise(
       (resolve) => setTimeout(() => {
@@ -20025,13 +20384,13 @@ For a complete security audit workflow, use the \`full-security-audit\` prompt.
 // src/mcp/services/McpDetectionService/CursorMcpDetectionService.ts
 import * as fs17 from "fs";
 import * as os9 from "os";
-import * as path17 from "path";
+import * as path18 from "path";
 
 // src/mcp/services/McpDetectionService/BaseMcpDetectionService.ts
 init_configs();
 import * as fs16 from "fs";
 import fetch6 from "node-fetch";
-import * as path16 from "path";
+import * as path17 from "path";
 
 // src/mcp/services/McpDetectionService/McpDetectionServiceUtils.ts
 import * as fs15 from "fs";
@@ -20040,14 +20399,14 @@ import * as os8 from "os";
 // src/mcp/services/McpDetectionService/VscodeMcpDetectionService.ts
 import * as fs18 from "fs";
 import * as os10 from "os";
-import * as path18 from "path";
+import * as path19 from "path";
 
 // src/mcp/tools/checkForNewAvailableFixes/CheckForNewAvailableFixesTool.ts
 import { z as z43 } from "zod";
 
 // src/mcp/services/PathValidation.ts
 import fs19 from "fs";
-import path19 from "path";
+import path20 from "path";
 async function validatePath(inputPath) {
   logDebug("Validating MCP path", { inputPath });
   if (/^\/[a-zA-Z]:\//.test(inputPath)) {
@@ -20079,7 +20438,7 @@ async function validatePath(inputPath) {
     logError(error);
     return { isValid: false, error, path: inputPath };
   }
-  const normalizedPath = path19.normalize(inputPath);
+  const normalizedPath = path20.normalize(inputPath);
   if (normalizedPath.includes("..")) {
     const error = `Normalized path contains path traversal patterns: ${inputPath}`;
     logError(error);
@@ -20731,7 +21090,7 @@ init_configs();
 import fs20 from "fs/promises";
 import nodePath from "path";
 var getLocalFiles = async ({
-  path: path26,
+  path: path27,
   maxFileSize = MCP_MAX_FILE_SIZE,
   maxFiles,
   isAllFilesScan,
@@ -20739,17 +21098,17 @@ var getLocalFiles = async ({
   scanRecentlyChangedFiles
 }) => {
   logDebug(`[${scanContext}] Starting getLocalFiles`, {
-    path: path26,
+    path: path27,
     maxFileSize,
     maxFiles,
     isAllFilesScan,
     scanRecentlyChangedFiles
   });
   try {
-    const resolvedRepoPath = await fs20.realpath(path26);
+    const resolvedRepoPath = await fs20.realpath(path27);
     logDebug(`[${scanContext}] Resolved repository path`, {
       resolvedRepoPath,
-      originalPath: path26
+      originalPath: path27
     });
     const gitService = new GitService(resolvedRepoPath, log);
     const gitValidation = await gitService.validateRepository();
@@ -20762,7 +21121,7 @@ var getLocalFiles = async ({
     if (!gitValidation.isValid || isAllFilesScan) {
       try {
         files = await FileUtils.getLastChangedFiles({
-          dir: path26,
+          dir: path27,
           maxFileSize,
           maxFiles,
           isAllFilesScan
@@ -20854,7 +21213,7 @@ 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: path26
+      path: path27
     });
     throw error;
   }
@@ -20864,7 +21223,7 @@ var getLocalFiles = async ({
 init_client_generates();
 init_GitService();
 import fs21 from "fs";
-import path20 from "path";
+import path21 from "path";
 import { z as z42 } from "zod";
 function extractPathFromPatch(patch) {
   const match = patch?.match(/diff --git a\/([^\s]+) b\//);
@@ -20950,7 +21309,7 @@ var LocalMobbFolderService = class {
           "[LocalMobbFolderService] Non-git repository detected, skipping .gitignore operations"
         );
       }
-      const mobbFolderPath = path20.join(
+      const mobbFolderPath = path21.join(
         this.repoPath,
         this.defaultMobbFolderName
       );
@@ -21122,7 +21481,7 @@ var LocalMobbFolderService = class {
         mobbFolderPath,
         baseFileName
       );
-      const filePath = path20.join(mobbFolderPath, uniqueFileName);
+      const filePath = path21.join(mobbFolderPath, uniqueFileName);
       await fs21.promises.writeFile(filePath, patch, "utf8");
       logInfo("[LocalMobbFolderService] Patch saved successfully", {
         filePath,
@@ -21180,11 +21539,11 @@ var LocalMobbFolderService = class {
    * @returns Unique filename that doesn't conflict with existing files
    */
   getUniqueFileName(folderPath, baseFileName) {
-    const baseName = path20.parse(baseFileName).name;
-    const extension = path20.parse(baseFileName).ext;
+    const baseName = path21.parse(baseFileName).name;
+    const extension = path21.parse(baseFileName).ext;
     let uniqueFileName = baseFileName;
     let index = 1;
-    while (fs21.existsSync(path20.join(folderPath, uniqueFileName))) {
+    while (fs21.existsSync(path21.join(folderPath, uniqueFileName))) {
       uniqueFileName = `${baseName}-${index}${extension}`;
       index++;
       if (index > 1e3) {
@@ -21215,7 +21574,7 @@ var LocalMobbFolderService = class {
     logDebug("[LocalMobbFolderService] Logging patch info", { fixId: fix.id });
     try {
       const mobbFolderPath = await this.getFolder();
-      const patchInfoPath = path20.join(mobbFolderPath, "patchInfo.md");
+      const patchInfoPath = path21.join(mobbFolderPath, "patchInfo.md");
       const markdownContent = this.generateFixMarkdown(fix, savedPatchFileName);
       let existingContent = "";
       if (fs21.existsSync(patchInfoPath)) {
@@ -21257,7 +21616,7 @@ var LocalMobbFolderService = class {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const patch = this.extractPatchFromFix(fix);
     const relativePatchedFilePath = patch ? extractPathFromPatch(patch) : null;
-    const patchedFilePath = relativePatchedFilePath ? path20.resolve(this.repoPath, relativePatchedFilePath) : null;
+    const patchedFilePath = relativePatchedFilePath ? path21.resolve(this.repoPath, relativePatchedFilePath) : null;
     const fixIdentifier = savedPatchFileName ? savedPatchFileName.replace(".patch", "") : fix.id;
     let markdown = `# Fix ${fixIdentifier}
 
@@ -21601,14 +21960,14 @@ import {
 } from "fs";
 import fs22 from "fs/promises";
 import parseDiff2 from "parse-diff";
-import path21 from "path";
+import path22 from "path";
 var PatchApplicationService = class {
   /**
    * Gets the appropriate comment syntax for a file based on its extension
    */
   static getCommentSyntax(filePath) {
-    const ext = path21.extname(filePath).toLowerCase();
-    const basename2 = path21.basename(filePath);
+    const ext = path22.extname(filePath).toLowerCase();
+    const basename2 = path22.basename(filePath);
     const commentMap = {
       // C-style languages (single line comments)
       ".js": "//",
@@ -21816,7 +22175,7 @@ var PatchApplicationService = class {
         }
       );
     }
-    const dirPath = path21.dirname(normalizedFilePath);
+    const dirPath = path22.dirname(normalizedFilePath);
     mkdirSync(dirPath, { recursive: true });
     writeFileSync(normalizedFilePath, finalContent, "utf8");
     return normalizedFilePath;
@@ -21825,9 +22184,9 @@ var PatchApplicationService = class {
     repositoryPath,
     targetPath
   }) {
-    const repoRoot = path21.resolve(repositoryPath);
-    const normalizedPath = path21.resolve(repoRoot, targetPath);
-    const repoRootWithSep = repoRoot.endsWith(path21.sep) ? repoRoot : `${repoRoot}${path21.sep}`;
+    const repoRoot = path22.resolve(repositoryPath);
+    const normalizedPath = path22.resolve(repoRoot, targetPath);
+    const repoRootWithSep = repoRoot.endsWith(path22.sep) ? repoRoot : `${repoRoot}${path22.sep}`;
     if (normalizedPath !== repoRoot && !normalizedPath.startsWith(repoRootWithSep)) {
       throw new Error(
         `Security violation: target path ${targetPath} resolves outside repository`
@@ -21836,7 +22195,7 @@ var PatchApplicationService = class {
     return {
       repoRoot,
       normalizedPath,
-      relativePath: path21.relative(repoRoot, normalizedPath)
+      relativePath: path22.relative(repoRoot, normalizedPath)
     };
   }
   /**
@@ -22118,7 +22477,7 @@ var PatchApplicationService = class {
         continue;
       }
       try {
-        const absolutePath = path21.resolve(repositoryPath, targetFile);
+        const absolutePath = path22.resolve(repositoryPath, targetFile);
         if (existsSync6(absolutePath)) {
           const stats = await fs22.stat(absolutePath);
           const fileModTime = stats.mtime.getTime();
@@ -22344,7 +22703,7 @@ var PatchApplicationService = class {
       fix,
       scanContext
     });
-    appliedFiles.push(path21.relative(repositoryPath, actualPath));
+    appliedFiles.push(path22.relative(repositoryPath, actualPath));
     logDebug(`[${scanContext}] Created new file: ${relativePath}`);
   }
   /**
@@ -22393,7 +22752,7 @@ var PatchApplicationService = class {
         fix,
         scanContext
       });
-      appliedFiles.push(path21.relative(repositoryPath, actualPath));
+      appliedFiles.push(path22.relative(repositoryPath, actualPath));
       logDebug(`[${scanContext}] Modified file: ${relativePath}`);
     }
   }
@@ -22590,7 +22949,7 @@ init_configs();
 // src/mcp/services/FileOperations.ts
 init_FileUtils();
 import fs23 from "fs";
-import path22 from "path";
+import path23 from "path";
 import AdmZip3 from "adm-zip";
 var FileOperations = class {
   /**
@@ -22610,10 +22969,10 @@ var FileOperations = class {
     let packedFilesCount = 0;
     const packedFiles = [];
     const excludedFiles = [];
-    const resolvedRepoPath = path22.resolve(repositoryPath);
+    const resolvedRepoPath = path23.resolve(repositoryPath);
     for (const filepath of fileList) {
-      const absoluteFilepath = path22.join(repositoryPath, filepath);
-      const resolvedFilePath = path22.resolve(absoluteFilepath);
+      const absoluteFilepath = path23.join(repositoryPath, filepath);
+      const resolvedFilePath = path23.resolve(absoluteFilepath);
       if (!resolvedFilePath.startsWith(resolvedRepoPath)) {
         const reason = "potential path traversal security risk";
         logDebug(`[FileOperations] Skipping ${filepath} due to ${reason}`);
@@ -22660,11 +23019,11 @@ var FileOperations = class {
     fileList,
     repositoryPath
   }) {
-    const resolvedRepoPath = path22.resolve(repositoryPath);
+    const resolvedRepoPath = path23.resolve(repositoryPath);
     const validatedPaths = [];
     for (const filepath of fileList) {
-      const absoluteFilepath = path22.join(repositoryPath, filepath);
-      const resolvedFilePath = path22.resolve(absoluteFilepath);
+      const absoluteFilepath = path23.join(repositoryPath, filepath);
+      const resolvedFilePath = path23.resolve(absoluteFilepath);
       if (!resolvedFilePath.startsWith(resolvedRepoPath)) {
         logDebug(
           `[FileOperations] Rejecting ${filepath} - path traversal attempt detected`
@@ -22692,7 +23051,7 @@ var FileOperations = class {
     for (const absolutePath of filePaths) {
       try {
         const content = await fs23.promises.readFile(absolutePath);
-        const relativePath = path22.basename(absolutePath);
+        const relativePath = path23.basename(absolutePath);
         fileDataArray.push({
           relativePath,
           absolutePath,
@@ -23004,14 +23363,14 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
    * since the last scan.
    */
   async scanForSecurityVulnerabilities({
-    path: path26,
+    path: path27,
     isAllDetectionRulesScan,
     isAllFilesScan,
     scanContext
   }) {
     this.hasAuthenticationFailed = false;
     logDebug(`[${scanContext}] Scanning for new security vulnerabilities`, {
-      path: path26
+      path: path27
     });
     if (!this.gqlClient) {
       logInfo(`[${scanContext}] No GQL client found, skipping scan`);
@@ -23027,11 +23386,11 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       logDebug(
         `[${scanContext}] Connected to the API, assembling list of files to scan`,
-        { path: path26 }
+        { path: path27 }
       );
       const isBackgroundScan = scanContext === ScanContext.BACKGROUND_INITIAL || scanContext === ScanContext.BACKGROUND_PERIODIC;
       const files = await getLocalFiles({
-        path: path26,
+        path: path27,
         isAllFilesScan,
         scanContext,
         scanRecentlyChangedFiles: !isBackgroundScan
@@ -23057,13 +23416,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
       const { fixReportId, projectId } = await scanFiles({
         fileList: filesToScan.map((file) => file.relativePath),
-        repositoryPath: path26,
+        repositoryPath: path27,
         gqlClient: this.gqlClient,
         isAllDetectionRulesScan,
         scanContext
       });
       logInfo(
-        `[${scanContext}] Security scan completed for ${path26} reportId: ${fixReportId} projectId: ${projectId}`
+        `[${scanContext}] Security scan completed for ${path27} reportId: ${fixReportId} projectId: ${projectId}`
       );
       if (isAllFilesScan) {
         return;
@@ -23357,13 +23716,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     });
     return scannedFiles.some((file) => file.relativePath === fixFile);
   }
-  async getFreshFixes({ path: path26 }) {
+  async getFreshFixes({ path: path27 }) {
     const scanContext = ScanContext.USER_REQUEST;
-    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path26 });
-    if (this.path !== path26) {
-      this.path = path26;
+    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path27 });
+    if (this.path !== path27) {
+      this.path = path27;
       this.reset();
-      logInfo(`[${scanContext}] Reset service state for new path`, { path: path26 });
+      logInfo(`[${scanContext}] Reset service state for new path`, { path: path27 });
     }
     try {
       const loginContext = createMcpLoginContext("check_new_fixes");
@@ -23382,7 +23741,7 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       throw error;
     }
-    this.triggerScan({ path: path26, gqlClient: this.gqlClient });
+    this.triggerScan({ path: path27, gqlClient: this.gqlClient });
     let isMvsAutoFixEnabled = null;
     try {
       isMvsAutoFixEnabled = await this.gqlClient.getMvsAutoFixSettings();
@@ -23416,33 +23775,33 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     return noFreshFixesPrompt;
   }
   triggerScan({
-    path: path26,
+    path: path27,
     gqlClient
   }) {
-    if (this.path !== path26) {
-      this.path = path26;
+    if (this.path !== path27) {
+      this.path = path27;
       this.reset();
-      logInfo(`Reset service state for new path in triggerScan`, { path: path26 });
+      logInfo(`Reset service state for new path in triggerScan`, { path: path27 });
     }
     this.gqlClient = gqlClient;
     if (!this.intervalId) {
-      this.startPeriodicScanning(path26);
-      this.executeInitialScan(path26);
-      void this.executeInitialFullScan(path26);
+      this.startPeriodicScanning(path27);
+      this.executeInitialScan(path27);
+      void this.executeInitialFullScan(path27);
     }
   }
-  startPeriodicScanning(path26) {
+  startPeriodicScanning(path27) {
     const scanContext = ScanContext.BACKGROUND_PERIODIC;
     logDebug(
       `[${scanContext}] Starting periodic scan for new security vulnerabilities`,
       {
-        path: path26
+        path: path27
       }
     );
     this.intervalId = setInterval(() => {
-      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path26 });
+      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path27 });
       this.scanForSecurityVulnerabilities({
-        path: path26,
+        path: path27,
         scanContext
       }).catch((error) => {
         logError(`[${scanContext}] Error during periodic security scan`, {
@@ -23451,45 +23810,45 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
     }, MCP_PERIODIC_CHECK_INTERVAL);
   }
-  async executeInitialFullScan(path26) {
+  async executeInitialFullScan(path27) {
     const scanContext = ScanContext.FULL_SCAN;
-    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path26 });
+    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path27 });
     logDebug(`[${scanContext}] Full scan paths scanned`, {
       fullScanPathsScanned: this.fullScanPathsScanned
     });
-    if (this.fullScanPathsScanned.includes(path26)) {
+    if (this.fullScanPathsScanned.includes(path27)) {
       logDebug(`[${scanContext}] Full scan already executed for this path`, {
-        path: path26
+        path: path27
       });
       return;
     }
     configStore.set("fullScanPathsScanned", [
       ...this.fullScanPathsScanned,
-      path26
+      path27
     ]);
     try {
       await this.scanForSecurityVulnerabilities({
-        path: path26,
+        path: path27,
         isAllFilesScan: true,
         isAllDetectionRulesScan: true,
         scanContext: ScanContext.FULL_SCAN
       });
-      if (!this.fullScanPathsScanned.includes(path26)) {
-        this.fullScanPathsScanned.push(path26);
+      if (!this.fullScanPathsScanned.includes(path27)) {
+        this.fullScanPathsScanned.push(path27);
         configStore.set("fullScanPathsScanned", this.fullScanPathsScanned);
       }
-      logInfo(`[${scanContext}] Full scan completed`, { path: path26 });
+      logInfo(`[${scanContext}] Full scan completed`, { path: path27 });
     } catch (error) {
       logError(`[${scanContext}] Error during initial full security scan`, {
         error
       });
     }
   }
-  executeInitialScan(path26) {
+  executeInitialScan(path27) {
     const scanContext = ScanContext.BACKGROUND_INITIAL;
-    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path26 });
+    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path27 });
     this.scanForSecurityVulnerabilities({
-      path: path26,
+      path: path27,
       scanContext: ScanContext.BACKGROUND_INITIAL
     }).catch((error) => {
       logError(`[${scanContext}] Error during initial security scan`, { error });
@@ -23586,9 +23945,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path26 = pathValidationResult.path;
+    const path27 = pathValidationResult.path;
     const resultText = await this.newFixesService.getFreshFixes({
-      path: path26
+      path: path27
     });
     logInfo("CheckForNewAvailableFixesTool execution completed", {
       resultText
@@ -23766,8 +24125,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 path26 = pathValidationResult.path;
-    const gitService = new GitService(path26, log);
+    const path27 = pathValidationResult.path;
+    const gitService = new GitService(path27, log);
     const gitValidation = await gitService.validateRepository();
     if (!gitValidation.isValid) {
       throw new Error(`Invalid git repository: ${gitValidation.error}`);
@@ -24152,9 +24511,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path26 = pathValidationResult.path;
+    const path27 = pathValidationResult.path;
     const files = await getLocalFiles({
-      path: path26,
+      path: path27,
       maxFileSize: MCP_MAX_FILE_SIZE,
       maxFiles: args.maxFiles,
       scanContext: ScanContext.USER_REQUEST,
@@ -24174,7 +24533,7 @@ Example payload:
     try {
       const fixResult = await this.vulnerabilityFixService.processVulnerabilities({
         fileList: files.map((file) => file.relativePath),
-        repositoryPath: path26,
+        repositoryPath: path27,
         offset: args.offset,
         limit: args.limit,
         isRescan: args.rescan || !!args.maxFiles
@@ -24414,10 +24773,10 @@ init_client_generates();
 init_urlParser2();
 
 // src/features/codeium_intellij/codeium_language_server_grpc_client.ts
-import path23 from "path";
+import path24 from "path";
 import * as grpc from "@grpc/grpc-js";
 import * as protoLoader from "@grpc/proto-loader";
-var PROTO_PATH = path23.join(
+var PROTO_PATH = path24.join(
   getModuleRootDir(),
   "src/features/codeium_intellij/proto/exa/language_server_pb/language_server.proto"
 );
@@ -24429,7 +24788,7 @@ function loadProto() {
     defaults: true,
     oneofs: true,
     includeDirs: [
-      path23.join(getModuleRootDir(), "src/features/codeium_intellij/proto")
+      path24.join(getModuleRootDir(), "src/features/codeium_intellij/proto")
     ]
   });
   return grpc.loadPackageDefinition(
@@ -24485,28 +24844,28 @@ async function getGrpcClient(port, csrf3) {
 // src/features/codeium_intellij/parse_intellij_logs.ts
 import fs25 from "fs";
 import os11 from "os";
-import path24 from "path";
+import path25 from "path";
 function getLogsDir() {
   if (process.platform === "darwin") {
-    return path24.join(os11.homedir(), "Library/Logs/JetBrains");
+    return path25.join(os11.homedir(), "Library/Logs/JetBrains");
   } else if (process.platform === "win32") {
-    return path24.join(
-      process.env["LOCALAPPDATA"] || path24.join(os11.homedir(), "AppData/Local"),
+    return path25.join(
+      process.env["LOCALAPPDATA"] || path25.join(os11.homedir(), "AppData/Local"),
       "JetBrains"
     );
   } else {
-    return path24.join(os11.homedir(), ".cache/JetBrains");
+    return path25.join(os11.homedir(), ".cache/JetBrains");
   }
 }
 function parseIdeLogDir(ideLogDir) {
   const logFiles = fs25.readdirSync(ideLogDir).filter((f) => /^idea(\.\d+)?\.log$/.test(f)).map((f) => ({
     name: f,
-    mtime: fs25.statSync(path24.join(ideLogDir, f)).mtimeMs
+    mtime: fs25.statSync(path25.join(ideLogDir, f)).mtimeMs
   })).sort((a, b) => a.mtime - b.mtime).map((f) => f.name);
   let latestCsrf = null;
   let latestPort = null;
   for (const logFile of logFiles) {
-    const lines = fs25.readFileSync(path24.join(ideLogDir, logFile), "utf-8").split("\n");
+    const lines = fs25.readFileSync(path25.join(ideLogDir, logFile), "utf-8").split("\n");
     for (const line of lines) {
       if (!line.includes(
         "com.codeium.intellij.language_server.LanguageServerProcessHandler"
@@ -24534,9 +24893,9 @@ function findRunningCodeiumLanguageServers() {
   const logsDir = getLogsDir();
   if (!fs25.existsSync(logsDir)) return results;
   for (const ide of fs25.readdirSync(logsDir)) {
-    let ideLogDir = path24.join(logsDir, ide);
+    let ideLogDir = path25.join(logsDir, ide);
     if (process.platform !== "darwin") {
-      ideLogDir = path24.join(ideLogDir, "log");
+      ideLogDir = path25.join(ideLogDir, "log");
     }
     if (!fs25.existsSync(ideLogDir) || !fs25.statSync(ideLogDir).isDirectory()) {
       continue;
@@ -24719,10 +25078,10 @@ function processChatStepCodeAction(step) {
 // src/features/codeium_intellij/install_hook.ts
 import fsPromises6 from "fs/promises";
 import os12 from "os";
-import path25 from "path";
+import path26 from "path";
 import chalk14 from "chalk";
 function getCodeiumHooksPath() {
-  return path25.join(os12.homedir(), ".codeium", "hooks.json");
+  return path26.join(os12.homedir(), ".codeium", "hooks.json");
 }
 async function readCodeiumHooks() {
   const hooksPath = getCodeiumHooksPath();
@@ -24735,7 +25094,7 @@ async function readCodeiumHooks() {
 }
 async function writeCodeiumHooks(config2) {
   const hooksPath = getCodeiumHooksPath();
-  const dir = path25.dirname(hooksPath);
+  const dir = path26.dirname(hooksPath);
   await fsPromises6.mkdir(dir, { recursive: true });
   await fsPromises6.writeFile(
     hooksPath,