mobbdev 1.0.217 → 1.1.0

package/dist/index.mjs

@@ -1323,7 +1323,7 @@ import Debug20 from "debug";
 import { hideBin } from "yargs/helpers";
 
 // src/args/yargs.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import yargs from "yargs/yargs";
 
 // src/args/commands/convert_to_sarif.ts
@@ -6247,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 path21 = [
+      const path22 = [
         prefixPath,
         owner,
         projectName,
@@ -6258,7 +6258,7 @@ async function getAdoSdk(params) {
         "items",
         "items"
       ].filter(Boolean).join("/");
-      return new URL(`${path21}?${params2}`, origin2).toString();
+      return new URL(`${path22}?${params2}`, origin2).toString();
     },
     async getAdoBranchList({ repoUrl }) {
       try {
@@ -7805,14 +7805,14 @@ function getGithubSdk(params = {}) {
       };
     },
     async getGithubBlameRanges(params2) {
-      const { ref, gitHubUrl, path: path21 } = params2;
+      const { ref, gitHubUrl, path: path22 } = params2;
       const { owner, repo } = parseGithubOwnerAndRepo(gitHubUrl);
       const res = await octokit.graphql(
         GET_BLAME_DOCUMENT,
         {
           owner,
           repo,
-          path: path21,
+          path: path22,
           ref
         }
       );
@@ -8179,11 +8179,11 @@ var GithubSCMLib = class extends SCMLib {
       markdownComment: comment
     });
   }
-  async getRepoBlameRanges(ref, path21) {
+  async getRepoBlameRanges(ref, path22) {
     this._validateUrl();
     return await this.githubSdk.getGithubBlameRanges({
       ref,
-      path: path21,
+      path: path22,
       gitHubUrl: this.url
     });
   }
@@ -8863,13 +8863,13 @@ function parseGitlabOwnerAndRepo(gitlabUrl) {
   const { organization, repoName, projectPath } = parsingResult;
   return { owner: organization, repo: repoName, projectPath };
 }
-async function getGitlabBlameRanges({ ref, gitlabUrl, path: path21 }, options) {
+async function getGitlabBlameRanges({ ref, gitlabUrl, path: path22 }, options) {
   const { projectPath } = parseGitlabOwnerAndRepo(gitlabUrl);
   const api2 = getGitBeaker({
     url: gitlabUrl,
     gitlabAuthToken: options?.gitlabAuthToken
   });
-  const resp = await api2.RepositoryFiles.allFileBlames(projectPath, path21, ref);
+  const resp = await api2.RepositoryFiles.allFileBlames(projectPath, path22, ref);
   let lineNumber = 1;
   return resp.filter((range) => range.lines).map((range) => {
     const oldLineNumber = lineNumber;
@@ -9046,10 +9046,10 @@ var GitlabSCMLib = class extends SCMLib {
       markdownComment: comment
     });
   }
-  async getRepoBlameRanges(ref, path21) {
+  async getRepoBlameRanges(ref, path22) {
     this._validateUrl();
     return await getGitlabBlameRanges(
-      { ref, path: path21, gitlabUrl: this.url },
+      { ref, path: path22, gitlabUrl: this.url },
       {
         url: this.url,
         gitlabAuthToken: this.accessToken
@@ -10051,7 +10051,9 @@ var mobbCliCommand = {
   review: "review",
   convertToSarif: "convert-to-sarif",
   mcp: "mcp",
-  uploadAiBlame: "upload-ai-blame"
+  uploadAiBlame: "upload-ai-blame",
+  claudeCodeInstallHook: "claude-code-install-hook",
+  claudeCodeProcessHook: "claude-code-process-hook"
 };
 var ScanContext = {
   FULL_SCAN: "FULL_SCAN",
@@ -11088,7 +11090,7 @@ async function postIssueComment(params) {
     fpDescription
   } = params;
   const {
-    path: path21,
+    path: path22,
     startLine,
     vulnerabilityReportIssue: {
       vulnerabilityReportIssueTags,
@@ -11103,7 +11105,7 @@ async function postIssueComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path21,
+    path: path22,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -11137,7 +11139,7 @@ async function postFixComment(params) {
     scanner
   } = params;
   const {
-    path: path21,
+    path: path22,
     startLine,
     vulnerabilityReportIssue: { fixId, vulnerabilityReportIssueTags, category },
     vulnerabilityReportIssueId
@@ -11155,7 +11157,7 @@ async function postFixComment(params) {
 Refresh the page in order to see the changes.`,
     pull_number: pullRequest,
     commit_id: commitSha,
-    path: path21,
+    path: path22,
     line: startLine
   });
   const commentId = commentRes.data.id;
@@ -11736,8 +11738,8 @@ if (typeof __filename !== "undefined") {
 }
 var costumeRequire = createRequire(moduleUrl);
 var getCheckmarxPath = () => {
-  const os9 = type();
-  const cxFileName = os9 === "Windows_NT" ? "cx.exe" : "cx";
+  const os10 = type();
+  const cxFileName = os10 === "Windows_NT" ? "cx.exe" : "cx";
   try {
     return costumeRequire.resolve(`.bin/${cxFileName}`);
   } catch (e) {
@@ -11881,8 +11883,8 @@ async function forkSnyk(args, { display }) {
 }
 async function getSnykReport(reportPath, repoRoot, { skipPrompts = false }) {
   debug17("get snyk report start %s %s", reportPath, repoRoot);
-  const config6 = await forkSnyk(["config"], { display: false });
-  const { message: configMessage } = config6;
+  const config7 = await forkSnyk(["config"], { display: false });
+  const { message: configMessage } = config7;
   if (!configMessage.includes("api: ")) {
     const snykLoginSpinner = createSpinner3().start();
     if (!skipPrompts) {
@@ -11894,7 +11896,7 @@ async function getSnykReport(reportPath, repoRoot, { skipPrompts = false }) {
     snykLoginSpinner.update({
       text: "\u{1F513} Waiting for Snyk login to complete"
     });
-    debug17("no token in the config %s", config6);
+    debug17("no token in the config %s", config7);
     await forkSnyk(["auth"], { display: true });
     snykLoginSpinner.success({ text: "\u{1F513} Login to Snyk Successful" });
   }
@@ -12894,6 +12896,645 @@ async function analyzeHandler(args) {
   await analyze(args, { skipPrompts: args.yes });
 }
 
+// src/args/commands/claude_code.ts
+import Configstore5 from "configstore";
+
+// src/features/claude_code/data_collector.ts
+import { z as z32 } from "zod";
+
+// src/args/commands/upload_ai_blame.ts
+import fsPromises3 from "fs/promises";
+import path11 from "path";
+import chalk9 from "chalk";
+import Configstore4 from "configstore";
+import { withFile } from "tmp-promise";
+import z31 from "zod";
+var PromptItemZ = z31.object({
+  type: z31.enum(["USER_PROMPT", "AI_RESPONSE", "TOOL_EXECUTION", "AI_THINKING"]),
+  attachedFiles: z31.array(
+    z31.object({
+      relativePath: z31.string(),
+      startLine: z31.number().optional()
+    })
+  ).optional(),
+  tokens: z31.object({
+    inputCount: z31.number(),
+    outputCount: z31.number()
+  }).optional(),
+  text: z31.string().optional(),
+  date: z31.date().optional(),
+  tool: z31.object({
+    name: z31.string(),
+    parameters: z31.string(),
+    result: z31.string(),
+    rawArguments: z31.string().optional(),
+    accepted: z31.boolean().optional()
+  }).optional()
+});
+var PromptItemArrayZ = z31.array(PromptItemZ);
+function uploadAiBlameBuilder(args) {
+  return args.option("prompt", {
+    type: "string",
+    array: true,
+    demandOption: true,
+    describe: chalk9.bold("Path(s) to prompt artifact(s) (one per session)")
+  }).option("inference", {
+    type: "string",
+    array: true,
+    demandOption: true,
+    describe: chalk9.bold(
+      "Path(s) to inference artifact(s) (one per session)"
+    )
+  }).option("ai-response-at", {
+    type: "string",
+    array: true,
+    describe: chalk9.bold(
+      "ISO timestamp(s) for AI response (one per session, defaults to now)"
+    )
+  }).option("model", {
+    type: "string",
+    array: true,
+    describe: chalk9.bold("AI model name(s) (optional, one per session)")
+  }).option("tool-name", {
+    type: "string",
+    array: true,
+    describe: chalk9.bold("Tool/IDE name(s) (optional, one per session)")
+  }).option("blame-type", {
+    type: "string",
+    array: true,
+    choices: Object.values(AiBlameInferenceType),
+    describe: chalk9.bold(
+      "Blame type(s) (optional, one per session, defaults to CHAT)"
+    )
+  }).strict();
+}
+async function uploadAiBlameHandlerFromExtension(args) {
+  const uploadArgs = {
+    prompt: [],
+    inference: [],
+    model: [],
+    toolName: [],
+    aiResponseAt: [],
+    blameType: []
+  };
+  await withFile(async (promptFile) => {
+    await fsPromises3.writeFile(
+      promptFile.path,
+      JSON.stringify(args.prompts, null, 2),
+      "utf-8"
+    );
+    uploadArgs.prompt.push(promptFile.path);
+    await withFile(async (inferenceFile) => {
+      await fsPromises3.writeFile(inferenceFile.path, args.inference, "utf-8");
+      uploadArgs.inference.push(inferenceFile.path);
+      uploadArgs.model.push(args.model);
+      uploadArgs.toolName.push(args.tool);
+      uploadArgs.aiResponseAt.push(args.responseTime);
+      uploadArgs.blameType.push(args.blameType || "CHAT" /* Chat */);
+      await uploadAiBlameHandler(uploadArgs, false);
+    });
+  });
+}
+var config5 = new Configstore4(packageJson.name, { apiToken: "" });
+async function getAuthenticatedGQLClientForIdeExtension() {
+  let gqlClient = new GQLClient({
+    apiKey: config5.get("apiToken") ?? "",
+    type: "apiKey"
+  });
+  gqlClient = await handleMobbLogin({
+    inGqlClient: gqlClient,
+    skipPrompts: true
+  });
+  return gqlClient;
+}
+async function uploadAiBlameHandler(args, exitOnError = true) {
+  const prompts = args.prompt || [];
+  const inferences = args.inference || [];
+  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(chalk9.red(errorMsg));
+    if (exitOnError) {
+      process.exit(1);
+    }
+    throw new Error(errorMsg);
+  }
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  const sessions = [];
+  for (let i = 0; i < prompts.length; i++) {
+    const promptPath = String(prompts[i]);
+    const inferencePath = String(inferences[i]);
+    try {
+      await Promise.all([
+        fsPromises3.access(promptPath),
+        fsPromises3.access(inferencePath)
+      ]);
+    } catch {
+      const errorMsg = `File not found for session ${i + 1}`;
+      console.error(chalk9.red(errorMsg));
+      if (exitOnError) {
+        process.exit(1);
+      }
+      throw new Error(errorMsg);
+    }
+    sessions.push({
+      promptFileName: path11.basename(promptPath),
+      inferenceFileName: path11.basename(inferencePath),
+      aiResponseAt: responseTimes[i] || nowIso,
+      model: models[i],
+      toolName: tools[i],
+      blameType: blameTypes[i] || "CHAT" /* Chat */
+    });
+  }
+  const authenticatedClient = await getAuthenticatedGQLClientForIdeExtension();
+  const initRes = await authenticatedClient.uploadAIBlameInferencesInitRaw({
+    sessions
+  });
+  const uploadSessions = initRes.uploadAIBlameInferencesInit?.uploadSessions ?? [];
+  if (uploadSessions.length !== sessions.length) {
+    const errorMsg = "Init failed to return expected number of sessions";
+    console.error(chalk9.red(errorMsg));
+    if (exitOnError) {
+      process.exit(1);
+    }
+    throw new Error(errorMsg);
+  }
+  for (let i = 0; i < uploadSessions.length; i++) {
+    const us = uploadSessions[i];
+    const promptPath = String(prompts[i]);
+    const inferencePath = String(inferences[i]);
+    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];
+    return {
+      aiBlameInferenceId: us.aiBlameInferenceId,
+      promptKey: us.prompt.uploadKey,
+      inferenceKey: us.inference.uploadKey,
+      aiResponseAt: s.aiResponseAt,
+      model: s.model,
+      toolName: s.toolName,
+      blameType: s.blameType
+    };
+  });
+  const finRes = await authenticatedClient.finalizeAIBlameInferencesUploadRaw({
+    sessions: finalizeSessions
+  });
+  const status = finRes?.finalizeAIBlameInferencesUpload?.status;
+  if (status !== "OK") {
+    const errorMsg = finRes?.finalizeAIBlameInferencesUpload?.error || "unknown error";
+    console.error(chalk9.red(errorMsg));
+    if (exitOnError) {
+      process.exit(1);
+    }
+    throw new Error(errorMsg);
+  }
+  console.log(chalk9.green("AI Blame uploads finalized successfully"));
+}
+
+// src/features/claude_code/transcript_parser.ts
+import fsPromises4 from "fs/promises";
+function processTranscriptLine(entry) {
+  const prompts = [];
+  let model;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let date;
+  if (entry.message?.model) {
+    model = entry.message.model;
+  }
+  if (entry.message?.usage) {
+    inputTokens = entry.message.usage.input_tokens || 0;
+    outputTokens = entry.message.usage.output_tokens || 0;
+  }
+  if (entry.timestamp) {
+    date = new Date(entry.timestamp);
+  }
+  if (entry.type === "user" && entry.message?.role === "user") {
+    if (typeof entry.message.content === "string") {
+      prompts.push({
+        type: "USER_PROMPT",
+        text: entry.message.content,
+        date: date || /* @__PURE__ */ new Date(),
+        tokens: inputTokens > 0 ? {
+          inputCount: inputTokens,
+          outputCount: 0
+        } : void 0
+      });
+    }
+  } else if (entry.type === "assistant" && entry.message?.role === "assistant") {
+    if (Array.isArray(entry.message.content)) {
+      for (const item of entry.message.content) {
+        if (item.type === "text" && item.text) {
+          prompts.push({
+            type: "AI_RESPONSE",
+            text: item.text,
+            date: date || /* @__PURE__ */ new Date(),
+            tokens: outputTokens > 0 ? {
+              inputCount: 0,
+              outputCount: outputTokens
+            } : void 0
+          });
+        } else if (item.type === "thinking" && item.thinking) {
+          prompts.push({
+            type: "AI_THINKING",
+            text: item.thinking,
+            date: date || /* @__PURE__ */ new Date()
+          });
+        }
+      }
+    }
+  }
+  return {
+    prompts,
+    model,
+    inputTokens,
+    outputTokens,
+    date
+  };
+}
+async function parseTranscriptAndCreateTrace(transcriptPath, hookData, inference) {
+  const content = await fsPromises4.readFile(transcriptPath, "utf-8");
+  const lines = content.trim().split("\n");
+  let currentToolIndex = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]?.trim() ?? "";
+    if (!line.includes('"type":"tool_use"')) continue;
+    const isEditTool = line.includes('"name":"Edit"');
+    const isWriteTool = line.includes('"name":"Write"');
+    if (isEditTool || isWriteTool) {
+      currentToolIndex = i;
+      break;
+    }
+  }
+  const startIndex = 0;
+  const endIndex = currentToolIndex === -1 ? lines.length - 1 : currentToolIndex - 1;
+  const prompts = [];
+  let model;
+  let latestDate;
+  for (let i = startIndex; i <= endIndex; i++) {
+    const line = lines[i]?.trim() ?? "";
+    const entry = JSON.parse(line);
+    const lineResult = processTranscriptLine(entry);
+    prompts.push(...lineResult.prompts);
+    if (lineResult.model && !model) {
+      model = lineResult.model;
+    }
+    if (lineResult.date) {
+      if (!latestDate || lineResult.date > latestDate) {
+        latestDate = lineResult.date;
+      }
+    }
+  }
+  prompts.push({
+    type: "TOOL_EXECUTION",
+    date: latestDate || /* @__PURE__ */ new Date(),
+    tool: {
+      name: hookData.tool_name,
+      parameters: JSON.stringify(hookData.tool_input, null, 2),
+      result: JSON.stringify(hookData.tool_response, null, 2),
+      rawArguments: JSON.stringify(hookData.tool_input),
+      accepted: true
+    }
+  });
+  return {
+    prompts,
+    inference,
+    model: model || "claude-sonnet-4",
+    // Use extracted model or fallback
+    tool: "Claude Code",
+    responseTime: (latestDate || /* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/features/claude_code/data_collector.ts
+var StructuredPatchItemSchema = z32.object({
+  oldStart: z32.number(),
+  oldLines: z32.number(),
+  newStart: z32.number(),
+  newLines: z32.number(),
+  lines: z32.array(z32.string())
+});
+var EditToolInputSchema = z32.object({
+  file_path: z32.string(),
+  old_string: z32.string(),
+  new_string: z32.string()
+});
+var WriteToolInputSchema = z32.object({
+  file_path: z32.string(),
+  content: z32.string()
+});
+var EditToolResponseSchema = z32.object({
+  filePath: z32.string(),
+  oldString: z32.string().optional(),
+  newString: z32.string().optional(),
+  originalFile: z32.string().optional(),
+  structuredPatch: z32.array(StructuredPatchItemSchema),
+  userModified: z32.boolean().optional(),
+  replaceAll: z32.boolean().optional()
+});
+var WriteToolResponseSchema = z32.object({
+  type: z32.string().optional(),
+  filePath: z32.string(),
+  content: z32.string().optional(),
+  structuredPatch: z32.array(z32.any()).optional()
+});
+var HookDataSchema = z32.object({
+  session_id: z32.string(),
+  transcript_path: z32.string(),
+  cwd: z32.string(),
+  permission_mode: z32.string().optional(),
+  hook_event_name: z32.literal("PostToolUse"),
+  tool_name: z32.enum(["Edit", "Write"]),
+  tool_input: z32.union([EditToolInputSchema, WriteToolInputSchema]),
+  tool_response: z32.union([EditToolResponseSchema, WriteToolResponseSchema])
+});
+async function readStdinData() {
+  return new Promise((resolve, reject) => {
+    let inputData = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      inputData += chunk;
+    });
+    process.stdin.on("end", () => {
+      try {
+        const parsedData = JSON.parse(inputData);
+        resolve(parsedData);
+      } catch (error) {
+        reject(
+          new Error(
+            `Failed to parse JSON from stdin: ${error.message}`
+          )
+        );
+      }
+    });
+    process.stdin.on("error", (error) => {
+      reject(new Error(`Error reading from stdin: ${error.message}`));
+    });
+  });
+}
+function validateHookData(data) {
+  return HookDataSchema.parse(data);
+}
+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));
+        }
+      }
+    }
+    return additions.join("\n");
+  }
+  return "";
+}
+async function collectHookData() {
+  const rawData = await readStdinData();
+  const hookData = validateHookData(rawData);
+  const inference = extractInference(hookData);
+  let tracePayload;
+  try {
+    tracePayload = await parseTranscriptAndCreateTrace(
+      hookData.transcript_path,
+      hookData,
+      inference
+    );
+  } catch (error) {
+    console.warn(
+      "Warning: Could not parse transcript:",
+      error.message
+    );
+    tracePayload = {
+      prompts: [
+        {
+          type: "TOOL_EXECUTION",
+          date: /* @__PURE__ */ new Date(),
+          tool: {
+            name: hookData.tool_name,
+            parameters: JSON.stringify(hookData.tool_input, null, 2),
+            result: JSON.stringify(hookData.tool_response, null, 2),
+            rawArguments: JSON.stringify(hookData.tool_input),
+            accepted: true
+          }
+        }
+      ],
+      inference,
+      model: "claude-sonnet-4",
+      tool: "Claude Code",
+      responseTime: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  return {
+    hookData,
+    inference,
+    tracePayload
+  };
+}
+async function processAndUploadHookData() {
+  const result = await collectHookData();
+  let uploadSuccess;
+  try {
+    await uploadAiBlameHandlerFromExtension({
+      prompts: result.tracePayload.prompts,
+      inference: result.tracePayload.inference,
+      model: result.tracePayload.model,
+      tool: result.tracePayload.tool,
+      responseTime: result.tracePayload.responseTime,
+      blameType: "CHAT" /* Chat */
+    });
+    uploadSuccess = true;
+  } catch (error) {
+    console.warn(
+      "Warning: Failed to upload trace data:",
+      error.message
+    );
+    uploadSuccess = false;
+  }
+  return {
+    ...result,
+    uploadSuccess
+  };
+}
+
+// src/features/claude_code/install_hook.ts
+import fsPromises5 from "fs/promises";
+import os2 from "os";
+import path12 from "path";
+import chalk10 from "chalk";
+var CLAUDE_SETTINGS_PATH = path12.join(os2.homedir(), ".claude", "settings.json");
+async function claudeSettingsExists() {
+  try {
+    await fsPromises5.access(CLAUDE_SETTINGS_PATH);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readClaudeSettings() {
+  const settingsContent = await fsPromises5.readFile(
+    CLAUDE_SETTINGS_PATH,
+    "utf-8"
+  );
+  return JSON.parse(settingsContent);
+}
+async function writeClaudeSettings(settings) {
+  await fsPromises5.writeFile(
+    CLAUDE_SETTINGS_PATH,
+    JSON.stringify(settings, null, 2),
+    "utf-8"
+  );
+}
+async function installMobbHooks() {
+  console.log(chalk10.blue("Installing Mobb hooks in Claude Code settings..."));
+  if (!await claudeSettingsExists()) {
+    console.log(chalk10.red("\u274C Claude Code settings file not found"));
+    console.log(chalk10.yellow(`Expected location: ${CLAUDE_SETTINGS_PATH}`));
+    console.log(chalk10.yellow("Is Claude Code installed on your system?"));
+    console.log(chalk10.yellow("Please install Claude Code and try again."));
+    throw new Error(
+      "Claude Code settings file not found. Is Claude Code installed?"
+    );
+  }
+  const settings = await readClaudeSettings();
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  if (!settings.hooks.PostToolUse) {
+    settings.hooks.PostToolUse = [];
+  }
+  const mobbHookConfig = {
+    matcher: "Edit|Write",
+    hooks: [
+      {
+        type: "command",
+        command: "npx --yes mobbdev@latest claude-code-process-hook"
+      }
+    ]
+  };
+  const existingHookIndex = settings.hooks.PostToolUse.findIndex(
+    (hook) => hook.matcher === "Edit|Write" && hook.hooks.some(
+      (h) => h.command?.includes("mobbdev@latest claude-code-process-hook")
+    )
+  );
+  if (existingHookIndex >= 0) {
+    console.log(chalk10.yellow("Mobb hook already exists, updating..."));
+    settings.hooks.PostToolUse[existingHookIndex] = mobbHookConfig;
+  } else {
+    console.log(chalk10.green("Adding new Mobb hook..."));
+    settings.hooks.PostToolUse.push(mobbHookConfig);
+  }
+  await writeClaudeSettings(settings);
+  console.log(
+    chalk10.green(
+      `\u2705 Mobb hooks installed successfully in ${CLAUDE_SETTINGS_PATH}`
+    )
+  );
+}
+
+// src/args/commands/claude_code.ts
+var config6 = new Configstore5(packageJson.name, { apiToken: "" });
+var claudeCodeInstallHookBuilder = (yargs2) => {
+  return yargs2.example(
+    "$0 claude-code-install-hook",
+    "Install Claude Code hooks for data collection"
+  ).strict();
+};
+var claudeCodeProcessHookBuilder = (yargs2) => {
+  return yargs2.example(
+    "$0 claude-code-process-hook",
+    "Process Claude Code hook data and upload to backend"
+  ).strict();
+};
+var claudeCodeInstallHookHandler = async () => {
+  try {
+    const gqlClient = new GQLClient({
+      apiKey: config6.get("apiToken") ?? "",
+      type: "apiKey"
+    });
+    await handleMobbLogin({
+      inGqlClient: gqlClient,
+      skipPrompts: false
+    });
+    await installMobbHooks();
+    process.exit(0);
+  } catch (error) {
+    console.error("Failed to install Claude Code hooks:", error);
+    process.exit(1);
+  }
+};
+var claudeCodeProcessHookHandler = async () => {
+  try {
+    const { hookData, inference, tracePayload, uploadSuccess } = await processAndUploadHookData();
+    console.log("Successfully processed Claude Code hook:");
+    console.log("Session ID:", hookData.session_id);
+    console.log("Tool:", hookData.tool_name);
+    console.log("Transcript path:", hookData.transcript_path);
+    console.log("Inference length:", inference.length);
+    const userPrompts = tracePayload.prompts.filter(
+      (p) => p.type === "USER_PROMPT"
+    );
+    const assistantResponses = tracePayload.prompts.filter(
+      (p) => p.type === "AI_RESPONSE"
+    );
+    const aiThinking = tracePayload.prompts.filter(
+      (p) => p.type === "AI_THINKING"
+    );
+    console.log("Conversation context extracted:");
+    console.log("- User prompts:", userPrompts.length);
+    console.log("- Assistant responses:", assistantResponses.length);
+    console.log("- AI thinking entries:", aiThinking.length);
+    console.log("- Model:", tracePayload.model);
+    const totalInputTokens = tracePayload.prompts.reduce(
+      (sum, p) => sum + (p.tokens?.inputCount || 0),
+      0
+    );
+    const totalOutputTokens = tracePayload.prompts.reduce(
+      (sum, p) => sum + (p.tokens?.outputCount || 0),
+      0
+    );
+    console.log("- Input tokens:", totalInputTokens);
+    console.log("- Output tokens:", totalOutputTokens);
+    console.log("Trace data formatted:");
+    console.log("- Prompt items:", tracePayload.prompts.length);
+    console.log("- Model:", tracePayload.model);
+    console.log("- Tool:", tracePayload.tool);
+    console.log("- Response time:", tracePayload.responseTime);
+    console.log("- Upload success:", uploadSuccess ? "\u2705" : "\u274C");
+    if (uploadSuccess) {
+      console.log("\u2705 Claude Code trace uploaded successfully to Mobb backend");
+    }
+    process.exit(0);
+  } catch (error) {
+    console.error("Failed to process Claude Code hook data:", error);
+    process.exit(1);
+  }
+};
+
 // src/mcp/core/McpServer.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -12905,7 +13546,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 
 // src/mcp/Logger.ts
-import Configstore4 from "configstore";
+import Configstore6 from "configstore";
 
 // src/mcp/services/WorkspaceService.ts
 var WorkspaceService = class {
@@ -12913,8 +13554,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(path21) {
-    this.knownWorkspacePath = path21;
+  static setKnownWorkspacePath(path22) {
+    this.knownWorkspacePath = path22;
   }
   /**
    * Gets the known workspace path that was previously validated
@@ -12991,7 +13632,7 @@ var Logger = class {
     __publicField(this, "lastKnownPath", null);
     this.host = WorkspaceService.getHost();
     this.unknownPathSuffix = Math.floor(1e3 + Math.random() * 9e3).toString();
-    this.mobbConfigStore = new Configstore4("mobb-logs", {});
+    this.mobbConfigStore = new Configstore6("mobb-logs", {});
     this.mobbConfigStore.set("version", packageJson.version);
   }
   /**
@@ -13061,135 +13702,135 @@ import { v4 as uuidv42 } from "uuid";
 init_configs();
 
 // src/mcp/types.ts
-import { z as z31 } from "zod";
-var ScanAndFixVulnerabilitiesToolSchema = z31.object({
-  path: z31.string()
+import { z as z33 } from "zod";
+var ScanAndFixVulnerabilitiesToolSchema = z33.object({
+  path: z33.string()
 });
-var VulnerabilityReportIssueTagSchema = z31.object({
-  vulnerability_report_issue_tag_value: z31.nativeEnum(
+var VulnerabilityReportIssueTagSchema = z33.object({
+  vulnerability_report_issue_tag_value: z33.nativeEnum(
     Vulnerability_Report_Issue_Tag_Enum
   )
 });
-var VulnerabilityReportIssueSchema = z31.object({
-  category: z31.any().optional().nullable(),
-  parsedIssueType: z31.nativeEnum(IssueType_Enum).nullable().optional(),
-  parsedSeverity: z31.nativeEnum(Vulnerability_Severity_Enum).nullable().optional(),
-  vulnerabilityReportIssueTags: z31.array(VulnerabilityReportIssueTagSchema)
+var VulnerabilityReportIssueSchema = z33.object({
+  category: z33.any().optional().nullable(),
+  parsedIssueType: z33.nativeEnum(IssueType_Enum).nullable().optional(),
+  parsedSeverity: z33.nativeEnum(Vulnerability_Severity_Enum).nullable().optional(),
+  vulnerabilityReportIssueTags: z33.array(VulnerabilityReportIssueTagSchema)
 });
-var SharedStateSchema = z31.object({
-  __typename: z31.literal("fix_shared_state").optional(),
-  id: z31.any(),
+var SharedStateSchema = z33.object({
+  __typename: z33.literal("fix_shared_state").optional(),
+  id: z33.any(),
   // GraphQL uses `any` type for UUID
-  downloadedBy: z31.array(z31.any().nullable()).optional().nullable()
+  downloadedBy: z33.array(z33.any().nullable()).optional().nullable()
 });
-var UnstructuredFixExtraContextSchema = z31.object({
-  __typename: z31.literal("UnstructuredFixExtraContext").optional(),
-  key: z31.string(),
-  value: z31.any()
+var UnstructuredFixExtraContextSchema = z33.object({
+  __typename: z33.literal("UnstructuredFixExtraContext").optional(),
+  key: z33.string(),
+  value: z33.any()
   // GraphQL JSON type
 });
-var FixExtraContextResponseSchema = z31.object({
-  __typename: z31.literal("FixExtraContextResponse").optional(),
-  extraContext: z31.array(UnstructuredFixExtraContextSchema),
-  fixDescription: z31.string()
+var FixExtraContextResponseSchema = z33.object({
+  __typename: z33.literal("FixExtraContextResponse").optional(),
+  extraContext: z33.array(UnstructuredFixExtraContextSchema),
+  fixDescription: z33.string()
 });
-var FixDataSchema = z31.object({
-  __typename: z31.literal("FixData"),
-  patch: z31.string(),
-  patchOriginalEncodingBase64: z31.string(),
+var FixDataSchema = z33.object({
+  __typename: z33.literal("FixData"),
+  patch: z33.string(),
+  patchOriginalEncodingBase64: z33.string(),
   extraContext: FixExtraContextResponseSchema
 });
-var GetFixNoFixErrorSchema = z31.object({
-  __typename: z31.literal("GetFixNoFixError")
+var GetFixNoFixErrorSchema = z33.object({
+  __typename: z33.literal("GetFixNoFixError")
 });
-var PatchAndQuestionsSchema = z31.union([FixDataSchema, GetFixNoFixErrorSchema]);
-var McpFixSchema = z31.object({
-  __typename: z31.literal("fix").optional(),
-  id: z31.any(),
+var PatchAndQuestionsSchema = z33.union([FixDataSchema, GetFixNoFixErrorSchema]);
+var McpFixSchema = z33.object({
+  __typename: z33.literal("fix").optional(),
+  id: z33.any(),
   // GraphQL uses `any` type for UUID
-  confidence: z31.number(),
-  safeIssueType: z31.string().nullable(),
-  severityText: z31.string().nullable(),
-  gitBlameLogin: z31.string().nullable().optional(),
+  confidence: z33.number(),
+  safeIssueType: z33.string().nullable(),
+  severityText: z33.string().nullable(),
+  gitBlameLogin: z33.string().nullable().optional(),
   // Optional in GraphQL
-  severityValue: z31.number().nullable(),
-  vulnerabilityReportIssues: z31.array(VulnerabilityReportIssueSchema),
+  severityValue: z33.number().nullable(),
+  vulnerabilityReportIssues: z33.array(VulnerabilityReportIssueSchema),
   sharedState: SharedStateSchema.nullable().optional(),
   // Optional in GraphQL
   patchAndQuestions: PatchAndQuestionsSchema,
   // Additional field added by the client
-  fixUrl: z31.string().optional()
+  fixUrl: z33.string().optional()
 });
-var FixAggregateSchema = z31.object({
-  __typename: z31.literal("fix_aggregate").optional(),
-  aggregate: z31.object({
-    __typename: z31.literal("fix_aggregate_fields").optional(),
-    count: z31.number()
+var FixAggregateSchema = z33.object({
+  __typename: z33.literal("fix_aggregate").optional(),
+  aggregate: z33.object({
+    __typename: z33.literal("fix_aggregate_fields").optional(),
+    count: z33.number()
   }).nullable()
 });
-var VulnerabilityReportIssueAggregateSchema = z31.object({
-  __typename: z31.literal("vulnerability_report_issue_aggregate").optional(),
-  aggregate: z31.object({
-    __typename: z31.literal("vulnerability_report_issue_aggregate_fields").optional(),
-    count: z31.number()
+var VulnerabilityReportIssueAggregateSchema = z33.object({
+  __typename: z33.literal("vulnerability_report_issue_aggregate").optional(),
+  aggregate: z33.object({
+    __typename: z33.literal("vulnerability_report_issue_aggregate_fields").optional(),
+    count: z33.number()
   }).nullable()
 });
-var RepoSchema = z31.object({
-  __typename: z31.literal("repo").optional(),
-  originalUrl: z31.string()
+var RepoSchema = z33.object({
+  __typename: z33.literal("repo").optional(),
+  originalUrl: z33.string()
 });
-var ProjectSchema = z31.object({
-  id: z31.any(),
+var ProjectSchema = z33.object({
+  id: z33.any(),
   // GraphQL uses `any` type for UUID
-  organizationId: z31.any()
+  organizationId: z33.any()
   // GraphQL uses `any` type for UUID
 });
-var VulnerabilityReportSchema = z31.object({
-  scanDate: z31.any().nullable(),
+var VulnerabilityReportSchema = z33.object({
+  scanDate: z33.any().nullable(),
   // GraphQL uses `any` type for timestamp
-  vendor: z31.string(),
+  vendor: z33.string(),
   // GraphQL generates as string, not enum
-  projectId: z31.any().optional(),
+  projectId: z33.any().optional(),
   // GraphQL uses `any` type for UUID
   project: ProjectSchema,
   totalVulnerabilityReportIssuesCount: VulnerabilityReportIssueAggregateSchema,
   notFixableVulnerabilityReportIssuesCount: VulnerabilityReportIssueAggregateSchema
 });
-var FixReportSummarySchema = z31.object({
-  __typename: z31.literal("fixReport").optional(),
-  id: z31.any(),
+var FixReportSummarySchema = z33.object({
+  __typename: z33.literal("fixReport").optional(),
+  id: z33.any(),
   // GraphQL uses `any` type for UUID
-  createdOn: z31.any(),
+  createdOn: z33.any(),
   // GraphQL uses `any` type for timestamp
   repo: RepoSchema.nullable(),
-  issueTypes: z31.any().nullable(),
+  issueTypes: z33.any().nullable(),
   // GraphQL uses `any` type for JSON
   CRITICAL: FixAggregateSchema,
   HIGH: FixAggregateSchema,
   MEDIUM: FixAggregateSchema,
   LOW: FixAggregateSchema,
-  fixes: z31.array(McpFixSchema),
-  userFixes: z31.array(McpFixSchema).optional(),
+  fixes: z33.array(McpFixSchema),
+  userFixes: z33.array(McpFixSchema).optional(),
   // Present in some responses but can be omitted
   filteredFixesCount: FixAggregateSchema,
   totalFixesCount: FixAggregateSchema,
   vulnerabilityReport: VulnerabilityReportSchema
 });
-var ExpiredReportSchema = z31.object({
-  __typename: z31.literal("fixReport").optional(),
-  id: z31.any(),
+var ExpiredReportSchema = z33.object({
+  __typename: z33.literal("fixReport").optional(),
+  id: z33.any(),
   // GraphQL uses `any` type for UUID
-  expirationOn: z31.any().nullable()
+  expirationOn: z33.any().nullable()
   // GraphQL uses `any` type for timestamp
 });
-var GetLatestReportByRepoUrlResponseSchema = z31.object({
-  __typename: z31.literal("query_root").optional(),
-  fixReport: z31.array(FixReportSummarySchema),
-  expiredReport: z31.array(ExpiredReportSchema)
+var GetLatestReportByRepoUrlResponseSchema = z33.object({
+  __typename: z33.literal("query_root").optional(),
+  fixReport: z33.array(FixReportSummarySchema),
+  expiredReport: z33.array(ExpiredReportSchema)
 });
 
 // src/mcp/services/ConfigStoreService.ts
-import Configstore5 from "configstore";
+import Configstore7 from "configstore";
 init_configs();
 function createConfigStore(defaultValues = { apiToken: "" }) {
   const API_URL2 = process.env["API_URL"] || MCP_DEFAULT_API_URL;
@@ -13201,7 +13842,7 @@ function createConfigStore(defaultValues = { apiToken: "" }) {
     domain = API_URL2.replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/:\d+$/, "");
   }
   const sanitizedDomain = domain.replace(/\./g, "_");
-  return new Configstore5(
+  return new Configstore7(
     `${packageJson.name}-${sanitizedDomain}`,
     defaultValues
   );
@@ -13213,7 +13854,7 @@ var configStore = getConfigStore();
 
 // src/mcp/services/McpAuthService.ts
 import crypto2 from "crypto";
-import os2 from "os";
+import os3 from "os";
 import open4 from "open";
 init_configs();
 var McpAuthService = class {
@@ -13257,7 +13898,7 @@ var McpAuthService = class {
     }
     logDebug(`cli login created ${loginId}`);
     const webLoginUrl2 = `${WEB_APP_URL}/mvs-login`;
-    const browserUrl = `${webLoginUrl2}/${loginId}?hostname=${os2.hostname()}`;
+    const browserUrl = `${webLoginUrl2}/${loginId}?hostname=${os3.hostname()}`;
     await this.openBrowser(browserUrl, isBackgoundCall);
     logDebug(`waiting for login to complete`);
     let newApiToken = null;
@@ -13918,8 +14559,8 @@ async function createAuthenticatedMcpGQLClient({
 // src/mcp/services/McpUsageService/host.ts
 import { execSync } from "child_process";
 import fs11 from "fs";
-import os3 from "os";
-import path11 from "path";
+import os4 from "os";
+import path13 from "path";
 var IDEs = ["cursor", "windsurf", "webstorm", "vscode", "claude"];
 var runCommand = (cmd) => {
   try {
@@ -13933,8 +14574,8 @@ var gitInfo = {
   email: runCommand("git config user.email")
 };
 var getClaudeWorkspacePaths = () => {
-  const home = os3.homedir();
-  const claudeIdePath = path11.join(home, ".claude", "ide");
+  const home = os4.homedir();
+  const claudeIdePath = path13.join(home, ".claude", "ide");
   const workspacePaths = [];
   if (!fs11.existsSync(claudeIdePath)) {
     return workspacePaths;
@@ -13942,7 +14583,7 @@ var getClaudeWorkspacePaths = () => {
   try {
     const lockFiles = fs11.readdirSync(claudeIdePath).filter((file) => file.endsWith(".lock"));
     for (const lockFile of lockFiles) {
-      const lockFilePath = path11.join(claudeIdePath, lockFile);
+      const lockFilePath = path13.join(claudeIdePath, lockFile);
       try {
         const lockContent = JSON.parse(fs11.readFileSync(lockFilePath, "utf8"));
         if (lockContent.workspaceFolders && Array.isArray(lockContent.workspaceFolders)) {
@@ -13962,29 +14603,29 @@ var getClaudeWorkspacePaths = () => {
   return workspacePaths;
 };
 var getMCPConfigPaths = (hostName) => {
-  const home = os3.homedir();
+  const home = os4.homedir();
   const currentDir = process.env["WORKSPACE_FOLDER_PATHS"] || process.env["PWD"] || process.cwd();
   switch (hostName.toLowerCase()) {
     case "cursor":
       return [
-        path11.join(currentDir, ".cursor", "mcp.json"),
+        path13.join(currentDir, ".cursor", "mcp.json"),
         // local first
-        path11.join(home, ".cursor", "mcp.json")
+        path13.join(home, ".cursor", "mcp.json")
       ];
     case "windsurf":
       return [
-        path11.join(currentDir, ".codeium", "mcp_config.json"),
+        path13.join(currentDir, ".codeium", "mcp_config.json"),
         // local first
-        path11.join(home, ".codeium", "windsurf", "mcp_config.json")
+        path13.join(home, ".codeium", "windsurf", "mcp_config.json")
       ];
     case "webstorm":
       return [];
     case "visualstudiocode":
     case "vscode":
       return [
-        path11.join(currentDir, ".vscode", "mcp.json"),
+        path13.join(currentDir, ".vscode", "mcp.json"),
         // local first
-        process.platform === "win32" ? path11.join(home, "AppData", "Roaming", "Code", "User", "mcp.json") : path11.join(
+        process.platform === "win32" ? path13.join(home, "AppData", "Roaming", "Code", "User", "mcp.json") : path13.join(
           home,
           "Library",
           "Application Support",
@@ -13995,13 +14636,13 @@ var getMCPConfigPaths = (hostName) => {
       ];
     case "claude": {
       const claudePaths = [
-        path11.join(currentDir, ".claude.json"),
+        path13.join(currentDir, ".claude.json"),
         // local first
-        path11.join(home, ".claude.json")
+        path13.join(home, ".claude.json")
       ];
       const workspacePaths = getClaudeWorkspacePaths();
       for (const workspacePath of workspacePaths) {
-        claudePaths.push(path11.join(workspacePath, ".mcp.json"));
+        claudePaths.push(path13.join(workspacePath, ".mcp.json"));
       }
       return claudePaths;
     }
@@ -14018,41 +14659,41 @@ var readConfigFile = (filePath) => {
     return null;
   }
 };
-var mergeConfigIntoResult = (config6, mergedConfig) => {
-  if (config6?.projects) {
+var mergeConfigIntoResult = (config7, mergedConfig) => {
+  if (config7?.projects) {
     const allMcpServers = {};
-    for (const projectPath in config6.projects) {
-      const project = config6.projects[projectPath];
+    for (const projectPath in config7.projects) {
+      const project = config7.projects[projectPath];
       if (project?.mcpServers) {
         Object.assign(allMcpServers, project.mcpServers);
       }
     }
     mergedConfig.mcpServers = { ...mergedConfig.mcpServers, ...allMcpServers };
   }
-  if (config6?.mcpServers) {
+  if (config7?.mcpServers) {
     mergedConfig.mcpServers = {
       ...mergedConfig.mcpServers,
-      ...config6.mcpServers
+      ...config7.mcpServers
     };
   }
-  if (config6?.servers) {
-    mergedConfig.servers = { ...mergedConfig.servers, ...config6.servers };
+  if (config7?.servers) {
+    mergedConfig.servers = { ...mergedConfig.servers, ...config7.servers };
   }
 };
 var readMCPConfig = (hostName) => {
   const configPaths = getMCPConfigPaths(hostName);
   const mergedConfig = {};
   for (const configPath of configPaths) {
-    const config6 = readConfigFile(configPath);
-    if (config6) {
-      mergeConfigIntoResult(config6, mergedConfig);
+    const config7 = readConfigFile(configPath);
+    if (config7) {
+      mergeConfigIntoResult(config7, mergedConfig);
     }
   }
   return Object.keys(mergedConfig).length > 0 ? mergedConfig : null;
 };
 var getRunningProcesses = () => {
   try {
-    return os3.platform() === "win32" ? execSync("tasklist", { encoding: "utf8" }) : execSync("ps aux", { encoding: "utf8" });
+    return os4.platform() === "win32" ? execSync("tasklist", { encoding: "utf8" }) : execSync("ps aux", { encoding: "utf8" });
   } catch {
     return "";
   }
@@ -14127,7 +14768,7 @@ var versionCommands = {
   }
 };
 var getProcessInfo = (pid) => {
-  const platform2 = os3.platform();
+  const platform2 = os4.platform();
   try {
     if (platform2 === "linux" || platform2 === "darwin") {
       const output = execSync(`ps -o pid=,ppid=,comm= -p ${pid}`, {
@@ -14162,20 +14803,20 @@ var getHostInfo = (additionalMcpList) => {
   const ideConfigPaths = /* @__PURE__ */ new Set();
   for (const ide of IDEs) {
     const configPaths = getMCPConfigPaths(ide);
-    configPaths.forEach((path21) => ideConfigPaths.add(path21));
+    configPaths.forEach((path22) => ideConfigPaths.add(path22));
   }
   const uniqueAdditionalPaths = additionalMcpList.filter(
-    (path21) => !ideConfigPaths.has(path21)
+    (path22) => !ideConfigPaths.has(path22)
   );
   for (const ide of IDEs) {
     const cfg = readMCPConfig(ide);
     if (cfg) allConfigs[ide] = cfg;
   }
   for (const additionalPath of uniqueAdditionalPaths) {
-    const config6 = readConfigFile(additionalPath);
-    if (!config6) continue;
+    const config7 = readConfigFile(additionalPath);
+    if (!config7) continue;
     const mergedConfig = {};
-    mergeConfigIntoResult(config6, mergedConfig);
+    mergeConfigIntoResult(config7, mergedConfig);
     if (Object.keys(mergedConfig).length > 0) {
       allConfigs["system"] = mergedConfig;
     }
@@ -14243,10 +14884,10 @@ var getHostInfo = (additionalMcpList) => {
     }
   }
   for (const { ide, name, command, isRunning } of servers) {
-    const config6 = allConfigs[ide] || null;
+    const config7 = allConfigs[ide] || null;
     const ideName = ide.charAt(0).toUpperCase() + ide.slice(1) || "Unknown";
     let ideVersion = "Unknown";
-    const platform2 = os3.platform();
+    const platform2 = os4.platform();
     const cmds = versionCommands[ideName]?.[platform2] ?? [];
     for (const cmd of cmds) {
       try {
@@ -14260,8 +14901,8 @@ var getHostInfo = (additionalMcpList) => {
       }
     }
     let mcpConfigObj = {};
-    if (config6) {
-      const allServers = config6.mcpServers || config6.servers || {};
+    if (config7) {
+      const allServers = config7.mcpServers || config7.servers || {};
       if (name in allServers && allServers[name]) {
         mcpConfigObj = allServers[name];
       }
@@ -14279,15 +14920,15 @@ var getHostInfo = (additionalMcpList) => {
 
 // src/mcp/services/McpUsageService/McpUsageService.ts
 import fetch5 from "node-fetch";
-import os5 from "os";
+import os6 from "os";
 import { v4 as uuidv43, v5 as uuidv5 } from "uuid";
 init_configs();
 
 // src/mcp/services/McpUsageService/system.ts
 init_configs();
 import fs12 from "fs";
-import os4 from "os";
-import path12 from "path";
+import os5 from "os";
+import path14 from "path";
 var MAX_DEPTH = 2;
 var patterns = ["mcp", "claude"];
 var isFileMatch = (fileName) => {
@@ -14307,7 +14948,7 @@ var searchDir = async (dir, depth = 0) => {
   if (depth > MAX_DEPTH) return results;
   const entries = await fs12.promises.readdir(dir, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
-    const fullPath = path12.join(dir, entry.name);
+    const fullPath = path14.join(dir, entry.name);
     if (entry.isFile() && isFileMatch(entry.name)) {
       results.push(fullPath);
     } else if (entry.isDirectory()) {
@@ -14321,17 +14962,17 @@ var searchDir = async (dir, depth = 0) => {
 };
 var findSystemMCPConfigs = async () => {
   try {
-    const home = os4.homedir();
-    const platform2 = os4.platform();
+    const home = os5.homedir();
+    const platform2 = os5.platform();
     const knownDirs = platform2 === "win32" ? [
-      path12.join(home, ".cursor"),
-      path12.join(home, "Documents"),
-      path12.join(home, "Downloads")
+      path14.join(home, ".cursor"),
+      path14.join(home, "Documents"),
+      path14.join(home, "Downloads")
     ] : [
-      path12.join(home, ".cursor"),
-      process.env["XDG_CONFIG_HOME"] || path12.join(home, ".config"),
-      path12.join(home, "Documents"),
-      path12.join(home, "Downloads")
+      path14.join(home, ".cursor"),
+      process.env["XDG_CONFIG_HOME"] || path14.join(home, ".config"),
+      path14.join(home, "Documents"),
+      path14.join(home, "Downloads")
     ];
     const timeoutPromise = new Promise(
       (resolve) => setTimeout(() => {
@@ -14394,7 +15035,7 @@ var McpUsageService = class {
   generateHostId() {
     const stored = configStore.get(this.configKey);
     if (stored?.mcpHostId) return stored.mcpHostId;
-    const interfaces = os5.networkInterfaces();
+    const interfaces = os6.networkInterfaces();
     const macs = [];
     for (const iface of Object.values(interfaces)) {
       if (!iface) continue;
@@ -14402,7 +15043,7 @@ var McpUsageService = class {
         if (net.mac && net.mac !== "00:00:00:00:00:00") macs.push(net.mac);
       }
     }
-    const macString = macs.length ? macs.sort().join(",") : `${os5.hostname()}-${uuidv43()}`;
+    const macString = macs.length ? macs.sort().join(",") : `${os6.hostname()}-${uuidv43()}`;
     const hostId = uuidv5(macString, uuidv5.DNS);
     logDebug("[UsageService] Generated new host ID", { hostId });
     return hostId;
@@ -14425,7 +15066,7 @@ var McpUsageService = class {
       mcpHostId,
       organizationId,
       mcpVersion: packageJson.version,
-      mcpOsName: os5.platform(),
+      mcpOsName: os6.platform(),
       mcps: JSON.stringify(mcps),
       status,
       userName: user.name,
@@ -14599,7 +15240,7 @@ var ToolRegistry = class {
 
 // src/mcp/core/McpServer.ts
 var McpServer = class {
-  constructor(config6, govOrgId = "") {
+  constructor(config7, govOrgId = "") {
     __publicField(this, "server");
     __publicField(this, "toolRegistry");
     __publicField(this, "promptRegistry");
@@ -14613,8 +15254,8 @@ var McpServer = class {
     this.mcpUsageService = govOrgId ? new McpUsageService(govOrgId) : null;
     this.server = new Server(
       {
-        name: config6.name,
-        version: config6.version
+        name: config7.name,
+        version: config7.version
       },
       {
         capabilities: {
@@ -14630,7 +15271,7 @@ var McpServer = class {
     this.setupParentProcessMonitoring();
     logInfo("MCP server instance created");
     logDebug("MCP server instance config", {
-      config: config6,
+      config: config7,
       parentPid: this.parentPid
     });
   }
@@ -15088,10 +15729,10 @@ var McpServer = class {
 };
 
 // src/mcp/prompts/CheckForNewVulnerabilitiesPrompt.ts
-import { z as z33 } from "zod";
+import { z as z35 } from "zod";
 
 // src/mcp/prompts/base/BasePrompt.ts
-import { z as z32 } from "zod";
+import { z as z34 } from "zod";
 var BasePrompt = class {
   getDefinition() {
     return {
@@ -15120,7 +15761,7 @@ var BasePrompt = class {
       const argsToValidate = args === void 0 ? {} : args;
       return this.argumentsValidationSchema.parse(argsToValidate);
     } catch (error) {
-      if (error instanceof z32.ZodError) {
+      if (error instanceof z34.ZodError) {
         const errorDetails = error.errors.map((e) => {
           const fieldPath = e.path.length > 0 ? e.path.join(".") : "root";
           const message = e.message === "Required" ? `Missing required argument '${fieldPath}'` : `Invalid value for '${fieldPath}': ${e.message}`;
@@ -15149,8 +15790,8 @@ var BasePrompt = class {
 };
 
 // src/mcp/prompts/CheckForNewVulnerabilitiesPrompt.ts
-var CheckForNewVulnerabilitiesArgsSchema = z33.object({
-  path: z33.string().optional()
+var CheckForNewVulnerabilitiesArgsSchema = z35.object({
+  path: z35.string().optional()
 });
 var CheckForNewVulnerabilitiesPrompt = class extends BasePrompt {
   constructor() {
@@ -15395,9 +16036,9 @@ Call the \`check_for_new_available_fixes\` tool now${args?.path ? ` for ${args.p
 };
 
 // src/mcp/prompts/FullSecurityAuditPrompt.ts
-import { z as z34 } from "zod";
-var FullSecurityAuditArgsSchema = z34.object({
-  path: z34.string().optional()
+import { z as z36 } from "zod";
+var FullSecurityAuditArgsSchema = z36.object({
+  path: z36.string().optional()
 });
 var FullSecurityAuditPrompt = class extends BasePrompt {
   constructor() {
@@ -15848,9 +16489,9 @@ Begin the audit now${args?.path ? ` for ${args.path}` : ""}.
 };
 
 // src/mcp/prompts/ReviewAndFixCriticalPrompt.ts
-import { z as z35 } from "zod";
-var ReviewAndFixCriticalArgsSchema = z35.object({
-  path: z35.string().optional()
+import { z as z37 } from "zod";
+var ReviewAndFixCriticalArgsSchema = z37.object({
+  path: z37.string().optional()
 });
 var ReviewAndFixCriticalPrompt = class extends BasePrompt {
   constructor() {
@@ -16154,9 +16795,9 @@ Start by scanning${args?.path ? ` ${args.path}` : " the repository"} and priorit
 };
 
 // src/mcp/prompts/ScanRecentChangesPrompt.ts
-import { z as z36 } from "zod";
-var ScanRecentChangesArgsSchema = z36.object({
-  path: z36.string().optional()
+import { z as z38 } from "zod";
+var ScanRecentChangesArgsSchema = z38.object({
+  path: z38.string().optional()
 });
 var ScanRecentChangesPrompt = class extends BasePrompt {
   constructor() {
@@ -16367,9 +17008,9 @@ You now have the guidance needed to perform a fast, targeted security scan of re
 };
 
 // src/mcp/prompts/ScanRepositoryPrompt.ts
-import { z as z37 } from "zod";
-var ScanRepositoryArgsSchema = z37.object({
-  path: z37.string().optional()
+import { z as z39 } from "zod";
+var ScanRepositoryArgsSchema = z39.object({
+  path: z39.string().optional()
 });
 var ScanRepositoryPrompt = class extends BasePrompt {
   constructor() {
@@ -16748,30 +17389,30 @@ 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";
+import * as os8 from "os";
+import * as path16 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";
+import * as path15 from "path";
 
 // src/mcp/services/McpDetectionService/McpDetectionServiceUtils.ts
 import * as fs13 from "fs";
-import * as os6 from "os";
+import * as os7 from "os";
 
 // src/mcp/services/McpDetectionService/VscodeMcpDetectionService.ts
 import * as fs16 from "fs";
-import * as os8 from "os";
-import * as path15 from "path";
+import * as os9 from "os";
+import * as path17 from "path";
 
 // src/mcp/tools/checkForNewAvailableFixes/CheckForNewAvailableFixesTool.ts
-import { z as z40 } from "zod";
+import { z as z42 } from "zod";
 
 // src/mcp/services/PathValidation.ts
 import fs17 from "fs";
-import path16 from "path";
+import path18 from "path";
 async function validatePath(inputPath) {
   logDebug("Validating MCP path", { inputPath });
   if (/^\/[a-zA-Z]:\//.test(inputPath)) {
@@ -16803,7 +17444,7 @@ async function validatePath(inputPath) {
     logError(error);
     return { isValid: false, error, path: inputPath };
   }
-  const normalizedPath = path16.normalize(inputPath);
+  const normalizedPath = path18.normalize(inputPath);
   if (normalizedPath.includes("..")) {
     const error = `Normalized path contains path traversal patterns: ${inputPath}`;
     logError(error);
@@ -16843,7 +17484,7 @@ async function validatePath(inputPath) {
 }
 
 // src/mcp/tools/base/BaseTool.ts
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 var BaseTool = class {
   getDefinition() {
     return {
@@ -16873,7 +17514,7 @@ var BaseTool = class {
     try {
       return this.inputValidationSchema.parse(args);
     } catch (error) {
-      if (error instanceof z38.ZodError) {
+      if (error instanceof z40.ZodError) {
         const errorDetails = error.errors.map((e) => {
           const fieldPath = e.path.length > 0 ? e.path.join(".") : "root";
           const message = e.message === "Required" ? `Missing required parameter '${fieldPath}'` : `Invalid value for '${fieldPath}': ${e.message}`;
@@ -17457,7 +18098,7 @@ init_configs();
 import fs18 from "fs/promises";
 import nodePath from "path";
 var getLocalFiles = async ({
-  path: path21,
+  path: path22,
   maxFileSize = MCP_MAX_FILE_SIZE,
   maxFiles,
   isAllFilesScan,
@@ -17465,17 +18106,17 @@ var getLocalFiles = async ({
   scanRecentlyChangedFiles
 }) => {
   logDebug(`[${scanContext}] Starting getLocalFiles`, {
-    path: path21,
+    path: path22,
     maxFileSize,
     maxFiles,
     isAllFilesScan,
     scanRecentlyChangedFiles
   });
   try {
-    const resolvedRepoPath = await fs18.realpath(path21);
+    const resolvedRepoPath = await fs18.realpath(path22);
     logDebug(`[${scanContext}] Resolved repository path`, {
       resolvedRepoPath,
-      originalPath: path21
+      originalPath: path22
     });
     const gitService = new GitService(resolvedRepoPath, log);
     const gitValidation = await gitService.validateRepository();
@@ -17488,7 +18129,7 @@ var getLocalFiles = async ({
     if (!gitValidation.isValid || isAllFilesScan) {
       try {
         files = await FileUtils.getLastChangedFiles({
-          dir: path21,
+          dir: path22,
           maxFileSize,
           maxFiles,
           isAllFilesScan
@@ -17580,7 +18221,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: path21
+      path: path22
     });
     throw error;
   }
@@ -17588,15 +18229,15 @@ var getLocalFiles = async ({
 
 // src/mcp/services/LocalMobbFolderService.ts
 import fs19 from "fs";
-import path17 from "path";
-import { z as z39 } from "zod";
+import path19 from "path";
+import { z as z41 } from "zod";
 init_GitService();
 function extractPathFromPatch(patch) {
   const match = patch?.match(/diff --git a\/([^\s]+) b\//);
   return match?.[1] ?? null;
 }
 function parsedIssueTypeRes(issueType) {
-  return z39.nativeEnum(IssueType_Enum).safeParse(issueType);
+  return z41.nativeEnum(IssueType_Enum).safeParse(issueType);
 }
 var LocalMobbFolderService = class {
   /**
@@ -17675,7 +18316,7 @@ var LocalMobbFolderService = class {
           "[LocalMobbFolderService] Non-git repository detected, skipping .gitignore operations"
         );
       }
-      const mobbFolderPath = path17.join(
+      const mobbFolderPath = path19.join(
         this.repoPath,
         this.defaultMobbFolderName
       );
@@ -17847,7 +18488,7 @@ var LocalMobbFolderService = class {
         mobbFolderPath,
         baseFileName
       );
-      const filePath = path17.join(mobbFolderPath, uniqueFileName);
+      const filePath = path19.join(mobbFolderPath, uniqueFileName);
       await fs19.promises.writeFile(filePath, patch, "utf8");
       logInfo("[LocalMobbFolderService] Patch saved successfully", {
         filePath,
@@ -17905,11 +18546,11 @@ var LocalMobbFolderService = class {
    * @returns Unique filename that doesn't conflict with existing files
    */
   getUniqueFileName(folderPath, baseFileName) {
-    const baseName = path17.parse(baseFileName).name;
-    const extension = path17.parse(baseFileName).ext;
+    const baseName = path19.parse(baseFileName).name;
+    const extension = path19.parse(baseFileName).ext;
     let uniqueFileName = baseFileName;
     let index = 1;
-    while (fs19.existsSync(path17.join(folderPath, uniqueFileName))) {
+    while (fs19.existsSync(path19.join(folderPath, uniqueFileName))) {
       uniqueFileName = `${baseName}-${index}${extension}`;
       index++;
       if (index > 1e3) {
@@ -17940,7 +18581,7 @@ var LocalMobbFolderService = class {
     logDebug("[LocalMobbFolderService] Logging patch info", { fixId: fix.id });
     try {
       const mobbFolderPath = await this.getFolder();
-      const patchInfoPath = path17.join(mobbFolderPath, "patchInfo.md");
+      const patchInfoPath = path19.join(mobbFolderPath, "patchInfo.md");
       const markdownContent = this.generateFixMarkdown(fix, savedPatchFileName);
       let existingContent = "";
       if (fs19.existsSync(patchInfoPath)) {
@@ -17982,7 +18623,7 @@ var LocalMobbFolderService = class {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const patch = this.extractPatchFromFix(fix);
     const relativePatchedFilePath = patch ? extractPathFromPatch(patch) : null;
-    const patchedFilePath = relativePatchedFilePath ? path17.resolve(this.repoPath, relativePatchedFilePath) : null;
+    const patchedFilePath = relativePatchedFilePath ? path19.resolve(this.repoPath, relativePatchedFilePath) : null;
     const fixIdentifier = savedPatchFileName ? savedPatchFileName.replace(".patch", "") : fix.id;
     let markdown = `# Fix ${fixIdentifier}
 
@@ -18326,14 +18967,14 @@ import {
 } from "fs";
 import fs20 from "fs/promises";
 import parseDiff2 from "parse-diff";
-import path18 from "path";
+import path20 from "path";
 var PatchApplicationService = class {
   /**
    * Gets the appropriate comment syntax for a file based on its extension
    */
   static getCommentSyntax(filePath) {
-    const ext = path18.extname(filePath).toLowerCase();
-    const basename2 = path18.basename(filePath);
+    const ext = path20.extname(filePath).toLowerCase();
+    const basename2 = path20.basename(filePath);
     const commentMap = {
       // C-style languages (single line comments)
       ".js": "//",
@@ -18536,7 +19177,7 @@ var PatchApplicationService = class {
         }
       );
     }
-    const dirPath = path18.dirname(filePath);
+    const dirPath = path20.dirname(filePath);
     mkdirSync(dirPath, { recursive: true });
     writeFileSync(filePath, finalContent, "utf8");
     return filePath;
@@ -18820,7 +19461,7 @@ var PatchApplicationService = class {
         continue;
       }
       try {
-        const absolutePath = path18.resolve(repositoryPath, targetFile);
+        const absolutePath = path20.resolve(repositoryPath, targetFile);
         if (existsSync6(absolutePath)) {
           const stats = await fs20.stat(absolutePath);
           const fileModTime = stats.mtime.getTime();
@@ -19011,11 +19652,11 @@ var PatchApplicationService = class {
   }) {
     const sanitizedRepoPath = String(repositoryPath || "").replace("\0", "").replace(/^(\.\.(\/|\\))+/, "");
     const sanitizedTargetFile = String(targetFile || "").replace("\0", "").replace(/^(\.\.(\/|\\))+/, "");
-    const absoluteFilePath = path18.resolve(
+    const absoluteFilePath = path20.resolve(
       sanitizedRepoPath,
       sanitizedTargetFile
     );
-    const relativePath = path18.relative(sanitizedRepoPath, absoluteFilePath);
+    const relativePath = path20.relative(sanitizedRepoPath, absoluteFilePath);
     if (relativePath.startsWith("..")) {
       throw new Error(
         `Security violation: target file ${targetFile} resolves outside repository`
@@ -19049,7 +19690,7 @@ var PatchApplicationService = class {
       fix,
       scanContext
     });
-    appliedFiles.push(path18.relative(repositoryPath, actualPath));
+    appliedFiles.push(path20.relative(repositoryPath, actualPath));
     logDebug(`[${scanContext}] Created new file: ${relativePath}`);
   }
   /**
@@ -19097,7 +19738,7 @@ var PatchApplicationService = class {
         fix,
         scanContext
       });
-      appliedFiles.push(path18.relative(repositoryPath, actualPath));
+      appliedFiles.push(path20.relative(repositoryPath, actualPath));
       logDebug(`[${scanContext}] Modified file: ${relativePath}`);
     }
   }
@@ -19293,7 +19934,7 @@ init_configs();
 // src/mcp/services/FileOperations.ts
 init_FileUtils();
 import fs21 from "fs";
-import path19 from "path";
+import path21 from "path";
 import AdmZip2 from "adm-zip";
 var FileOperations = class {
   /**
@@ -19313,10 +19954,10 @@ var FileOperations = class {
     let packedFilesCount = 0;
     const packedFiles = [];
     const excludedFiles = [];
-    const resolvedRepoPath = path19.resolve(repositoryPath);
+    const resolvedRepoPath = path21.resolve(repositoryPath);
     for (const filepath of fileList) {
-      const absoluteFilepath = path19.join(repositoryPath, filepath);
-      const resolvedFilePath = path19.resolve(absoluteFilepath);
+      const absoluteFilepath = path21.join(repositoryPath, filepath);
+      const resolvedFilePath = path21.resolve(absoluteFilepath);
       if (!resolvedFilePath.startsWith(resolvedRepoPath)) {
         const reason = "potential path traversal security risk";
         logDebug(`[FileOperations] Skipping ${filepath} due to ${reason}`);
@@ -19363,11 +20004,11 @@ var FileOperations = class {
     fileList,
     repositoryPath
   }) {
-    const resolvedRepoPath = path19.resolve(repositoryPath);
+    const resolvedRepoPath = path21.resolve(repositoryPath);
     const validatedPaths = [];
     for (const filepath of fileList) {
-      const absoluteFilepath = path19.join(repositoryPath, filepath);
-      const resolvedFilePath = path19.resolve(absoluteFilepath);
+      const absoluteFilepath = path21.join(repositoryPath, filepath);
+      const resolvedFilePath = path21.resolve(absoluteFilepath);
       if (!resolvedFilePath.startsWith(resolvedRepoPath)) {
         logDebug(
           `[FileOperations] Rejecting ${filepath} - path traversal attempt detected`
@@ -19395,7 +20036,7 @@ var FileOperations = class {
     for (const absolutePath of filePaths) {
       try {
         const content = await fs21.promises.readFile(absolutePath);
-        const relativePath = path19.basename(absolutePath);
+        const relativePath = path21.basename(absolutePath);
         fileDataArray.push({
           relativePath,
           absolutePath,
@@ -19707,14 +20348,14 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
    * since the last scan.
    */
   async scanForSecurityVulnerabilities({
-    path: path21,
+    path: path22,
     isAllDetectionRulesScan,
     isAllFilesScan,
     scanContext
   }) {
     this.hasAuthenticationFailed = false;
     logDebug(`[${scanContext}] Scanning for new security vulnerabilities`, {
-      path: path21
+      path: path22
     });
     if (!this.gqlClient) {
       logInfo(`[${scanContext}] No GQL client found, skipping scan`);
@@ -19730,11 +20371,11 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       logDebug(
         `[${scanContext}] Connected to the API, assembling list of files to scan`,
-        { path: path21 }
+        { path: path22 }
       );
       const isBackgroundScan = scanContext === ScanContext.BACKGROUND_INITIAL || scanContext === ScanContext.BACKGROUND_PERIODIC;
       const files = await getLocalFiles({
-        path: path21,
+        path: path22,
         isAllFilesScan,
         scanContext,
         scanRecentlyChangedFiles: !isBackgroundScan
@@ -19760,13 +20401,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
       const { fixReportId, projectId } = await scanFiles({
         fileList: filesToScan.map((file) => file.relativePath),
-        repositoryPath: path21,
+        repositoryPath: path22,
         gqlClient: this.gqlClient,
         isAllDetectionRulesScan,
         scanContext
       });
       logInfo(
-        `[${scanContext}] Security scan completed for ${path21} reportId: ${fixReportId} projectId: ${projectId}`
+        `[${scanContext}] Security scan completed for ${path22} reportId: ${fixReportId} projectId: ${projectId}`
       );
       if (isAllFilesScan) {
         return;
@@ -20060,13 +20701,13 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     });
     return scannedFiles.some((file) => file.relativePath === fixFile);
   }
-  async getFreshFixes({ path: path21 }) {
+  async getFreshFixes({ path: path22 }) {
     const scanContext = ScanContext.USER_REQUEST;
-    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path21 });
-    if (this.path !== path21) {
-      this.path = path21;
+    logDebug(`[${scanContext}] Getting fresh fixes`, { path: path22 });
+    if (this.path !== path22) {
+      this.path = path22;
       this.reset();
-      logInfo(`[${scanContext}] Reset service state for new path`, { path: path21 });
+      logInfo(`[${scanContext}] Reset service state for new path`, { path: path22 });
     }
     try {
       this.gqlClient = await createAuthenticatedMcpGQLClient();
@@ -20084,7 +20725,7 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       }
       throw error;
     }
-    this.triggerScan({ path: path21, gqlClient: this.gqlClient });
+    this.triggerScan({ path: path22, gqlClient: this.gqlClient });
     let isMvsAutoFixEnabled = null;
     try {
       isMvsAutoFixEnabled = await this.gqlClient.getMvsAutoFixSettings();
@@ -20118,33 +20759,33 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
     return noFreshFixesPrompt;
   }
   triggerScan({
-    path: path21,
+    path: path22,
     gqlClient
   }) {
-    if (this.path !== path21) {
-      this.path = path21;
+    if (this.path !== path22) {
+      this.path = path22;
       this.reset();
-      logInfo(`Reset service state for new path in triggerScan`, { path: path21 });
+      logInfo(`Reset service state for new path in triggerScan`, { path: path22 });
     }
     this.gqlClient = gqlClient;
     if (!this.intervalId) {
-      this.startPeriodicScanning(path21);
-      this.executeInitialScan(path21);
-      void this.executeInitialFullScan(path21);
+      this.startPeriodicScanning(path22);
+      this.executeInitialScan(path22);
+      void this.executeInitialFullScan(path22);
     }
   }
-  startPeriodicScanning(path21) {
+  startPeriodicScanning(path22) {
     const scanContext = ScanContext.BACKGROUND_PERIODIC;
     logDebug(
       `[${scanContext}] Starting periodic scan for new security vulnerabilities`,
       {
-        path: path21
+        path: path22
       }
     );
     this.intervalId = setInterval(() => {
-      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path21 });
+      logDebug(`[${scanContext}] Triggering periodic security scan`, { path: path22 });
       this.scanForSecurityVulnerabilities({
-        path: path21,
+        path: path22,
         scanContext
       }).catch((error) => {
         logError(`[${scanContext}] Error during periodic security scan`, {
@@ -20153,45 +20794,45 @@ var _CheckForNewAvailableFixesService = class _CheckForNewAvailableFixesService
       });
     }, MCP_PERIODIC_CHECK_INTERVAL);
   }
-  async executeInitialFullScan(path21) {
+  async executeInitialFullScan(path22) {
     const scanContext = ScanContext.FULL_SCAN;
-    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path21 });
+    logDebug(`[${scanContext}] Triggering initial full security scan`, { path: path22 });
     logDebug(`[${scanContext}] Full scan paths scanned`, {
       fullScanPathsScanned: this.fullScanPathsScanned
     });
-    if (this.fullScanPathsScanned.includes(path21)) {
+    if (this.fullScanPathsScanned.includes(path22)) {
       logDebug(`[${scanContext}] Full scan already executed for this path`, {
-        path: path21
+        path: path22
       });
       return;
     }
     configStore.set("fullScanPathsScanned", [
       ...this.fullScanPathsScanned,
-      path21
+      path22
     ]);
     try {
       await this.scanForSecurityVulnerabilities({
-        path: path21,
+        path: path22,
         isAllFilesScan: true,
         isAllDetectionRulesScan: true,
         scanContext: ScanContext.FULL_SCAN
       });
-      if (!this.fullScanPathsScanned.includes(path21)) {
-        this.fullScanPathsScanned.push(path21);
+      if (!this.fullScanPathsScanned.includes(path22)) {
+        this.fullScanPathsScanned.push(path22);
         configStore.set("fullScanPathsScanned", this.fullScanPathsScanned);
       }
-      logInfo(`[${scanContext}] Full scan completed`, { path: path21 });
+      logInfo(`[${scanContext}] Full scan completed`, { path: path22 });
     } catch (error) {
       logError(`[${scanContext}] Error during initial full security scan`, {
         error
       });
     }
   }
-  executeInitialScan(path21) {
+  executeInitialScan(path22) {
     const scanContext = ScanContext.BACKGROUND_INITIAL;
-    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path21 });
+    logDebug(`[${scanContext}] Triggering initial security scan`, { path: path22 });
     this.scanForSecurityVulnerabilities({
-      path: path21,
+      path: path22,
       scanContext: ScanContext.BACKGROUND_INITIAL
     }).catch((error) => {
       logError(`[${scanContext}] Error during initial security scan`, { error });
@@ -20270,8 +20911,8 @@ Example payload:
       },
       required: ["path"]
     });
-    __publicField(this, "inputValidationSchema", z40.object({
-      path: z40.string().describe(
+    __publicField(this, "inputValidationSchema", z42.object({
+      path: z42.string().describe(
         "Full local path to the cloned git repository to check for new available fixes"
       )
     }));
@@ -20288,9 +20929,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path21 = pathValidationResult.path;
+    const path22 = pathValidationResult.path;
     const resultText = await this.newFixesService.getFreshFixes({
-      path: path21
+      path: path22
     });
     logInfo("CheckForNewAvailableFixesTool execution completed", {
       resultText
@@ -20301,7 +20942,7 @@ Example payload:
 
 // src/mcp/tools/fetchAvailableFixes/FetchAvailableFixesTool.ts
 init_GitService();
-import { z as z41 } from "zod";
+import { z as z43 } from "zod";
 
 // src/mcp/tools/fetchAvailableFixes/FetchAvailableFixesService.ts
 init_configs();
@@ -20443,16 +21084,16 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
       },
       required: ["path"]
     });
-    __publicField(this, "inputValidationSchema", z41.object({
-      path: z41.string().describe(
+    __publicField(this, "inputValidationSchema", z43.object({
+      path: z43.string().describe(
         "Full local path to the cloned git repository to check for available fixes"
       ),
-      offset: z41.number().optional().describe("Optional offset for pagination"),
-      limit: z41.number().optional().describe("Optional maximum number of fixes to return"),
-      fileFilter: z41.array(z41.string()).optional().describe(
+      offset: z43.number().optional().describe("Optional offset for pagination"),
+      limit: z43.number().optional().describe("Optional maximum number of fixes to return"),
+      fileFilter: z43.array(z43.string()).optional().describe(
         "Optional list of file paths relative to the path parameter to filter fixes by. INCOMPATIBLE with fetchFixesFromAnyFile"
       ),
-      fetchFixesFromAnyFile: z41.boolean().optional().describe(
+      fetchFixesFromAnyFile: z43.boolean().optional().describe(
         "Optional boolean to fetch fixes for all files. INCOMPATIBLE with fileFilter"
       )
     }));
@@ -20467,8 +21108,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 path21 = pathValidationResult.path;
-    const gitService = new GitService(path21, log);
+    const path22 = pathValidationResult.path;
+    const gitService = new GitService(path22, log);
     const gitValidation = await gitService.validateRepository();
     if (!gitValidation.isValid) {
       throw new Error(`Invalid git repository: ${gitValidation.error}`);
@@ -20521,7 +21162,7 @@ Call this tool instead of ${MCP_TOOL_SCAN_AND_FIX_VULNERABILITIES} when you only
 };
 
 // src/mcp/tools/mcpChecker/mcpCheckerTool.ts
-import z42 from "zod";
+import z44 from "zod";
 
 // src/mcp/tools/mcpChecker/mcpCheckerService.ts
 var _McpCheckerService = class _McpCheckerService {
@@ -20582,7 +21223,7 @@ var McpCheckerTool = class extends BaseTool {
     __publicField(this, "displayName", "MCP Checker");
     // A detailed description to guide the LLM on when and how to invoke this tool.
     __publicField(this, "description", "Check the MCP servers running on this IDE against organization policies.");
-    __publicField(this, "inputValidationSchema", z42.object({}));
+    __publicField(this, "inputValidationSchema", z44.object({}));
     __publicField(this, "inputSchema", {
       type: "object",
       properties: {},
@@ -20608,7 +21249,7 @@ var McpCheckerTool = class extends BaseTool {
 };
 
 // src/mcp/tools/scanAndFixVulnerabilities/ScanAndFixVulnerabilitiesTool.ts
-import z43 from "zod";
+import z45 from "zod";
 init_configs();
 
 // src/mcp/tools/scanAndFixVulnerabilities/ScanAndFixVulnerabilitiesService.ts
@@ -20795,17 +21436,17 @@ Example payload:
   "rescan": false
 }`);
     __publicField(this, "hasAuthentication", true);
-    __publicField(this, "inputValidationSchema", z43.object({
-      path: z43.string().describe(
+    __publicField(this, "inputValidationSchema", z45.object({
+      path: z45.string().describe(
         "Full local path to repository to scan and fix vulnerabilities"
       ),
-      offset: z43.number().optional().describe("Optional offset for pagination"),
-      limit: z43.number().optional().describe("Optional maximum number of results to return"),
-      maxFiles: z43.number().optional().describe(
+      offset: z45.number().optional().describe("Optional offset for pagination"),
+      limit: z45.number().optional().describe("Optional maximum number of results to return"),
+      maxFiles: z45.number().optional().describe(
         `Optional maximum number of files to scan (default: ${MCP_DEFAULT_MAX_FILES_TO_SCAN}). Increase for comprehensive scans of larger codebases or decrease for faster focused scans.`
       ),
-      rescan: z43.boolean().optional().describe("Optional whether to rescan the repository"),
-      scanRecentlyChangedFiles: z43.boolean().optional().describe(
+      rescan: z45.boolean().optional().describe("Optional whether to rescan the repository"),
+      scanRecentlyChangedFiles: z45.boolean().optional().describe(
         "Optional whether to automatically scan recently changed files when no changed files are found in git status. If false, the tool will prompt the user instead."
       )
     }));
@@ -20856,9 +21497,9 @@ Example payload:
         `Invalid path: potential security risk detected in path: ${pathValidationResult.error}`
       );
     }
-    const path21 = pathValidationResult.path;
+    const path22 = pathValidationResult.path;
     const files = await getLocalFiles({
-      path: path21,
+      path: path22,
       maxFileSize: MCP_MAX_FILE_SIZE,
       maxFiles: args.maxFiles,
       scanContext: ScanContext.USER_REQUEST,
@@ -20878,7 +21519,7 @@ Example payload:
     try {
       const fixResult = await this.vulnerabilityFixService.processVulnerabilities({
         fileList: files.map((file) => file.relativePath),
-        repositoryPath: path21,
+        repositoryPath: path22,
         offset: args.offset,
         limit: args.limit,
         isRescan: args.rescan || !!args.maxFiles
@@ -20983,32 +21624,32 @@ var mcpHandler = async (_args) => {
 
 // src/args/commands/review.ts
 import fs22 from "fs";
-import chalk9 from "chalk";
+import chalk11 from "chalk";
 function reviewBuilder(yargs2) {
   return yargs2.option("f", {
     alias: "scan-file",
     demandOption: true,
     type: "string",
-    describe: chalk9.bold(
+    describe: chalk11.bold(
       "Select the vulnerability report to analyze (Checkmarx, Snyk, Fortify, CodeQL, Sonarqube, Semgrep)"
     )
   }).option("repo", { ...repoOption, demandOption: true }).option("scanner", { ...scannerOptions, demandOption: true }).option("ref", { ...refOption, demandOption: true }).option("ch", {
     alias: "commit-hash",
-    describe: chalk9.bold("Hash of the commit"),
+    describe: chalk11.bold("Hash of the commit"),
     type: "string",
     demandOption: true
   }).option("mobb-project-name", mobbProjectNameOption).option("api-key", { ...apiKeyOption, demandOption: true }).option("commit-hash", { ...commitHashOption, demandOption: true }).option("github-token", {
-    describe: chalk9.bold("Github action token"),
+    describe: chalk11.bold("Github action token"),
     type: "string",
     demandOption: true
   }).option("pull-request", {
     alias: ["pr", "pr-number", "pr-id"],
-    describe: chalk9.bold("Number of the pull request"),
+    describe: chalk11.bold("Number of the pull request"),
     type: "number",
     demandOption: true
   }).option("p", {
     alias: "src-path",
-    describe: chalk9.bold(
+    describe: chalk11.bold(
       "Path to the repository folder with the source code"
     ),
     type: "string",
@@ -21021,7 +21662,7 @@ function reviewBuilder(yargs2) {
 function validateReviewOptions(argv) {
   if (!fs22.existsSync(argv.f)) {
     throw new CliError(`
-Can't access ${chalk9.bold(argv.f)}`);
+Can't access ${chalk11.bold(argv.f)}`);
   }
   validateRepoUrl(argv);
   validateReportFileFormat(argv.f);
@@ -21091,248 +21732,77 @@ async function addScmTokenHandler(args) {
   await addScmToken(args);
 }
 
-// src/args/commands/upload_ai_blame.ts
-import fsPromises3 from "fs/promises";
-import path20 from "path";
-import chalk10 from "chalk";
-import Configstore6 from "configstore";
-import { withFile } from "tmp-promise";
-import z44 from "zod";
-var PromptItemZ = z44.object({
-  type: z44.enum(["USER_PROMPT", "AI_RESPONSE", "TOOL_EXECUTION", "AI_THINKING"]),
-  attachedFiles: z44.array(
-    z44.object({
-      relativePath: z44.string(),
-      startLine: z44.number().optional()
-    })
-  ).optional(),
-  tokens: z44.object({
-    inputCount: z44.number(),
-    outputCount: z44.number()
-  }).optional(),
-  text: z44.string().optional(),
-  date: z44.date().optional(),
-  tool: z44.object({
-    name: z44.string(),
-    parameters: z44.string(),
-    result: z44.string(),
-    rawArguments: z44.string().optional(),
-    accepted: z44.boolean().optional()
-  }).optional()
-});
-var PromptItemArrayZ = z44.array(PromptItemZ);
-function uploadAiBlameBuilder(args) {
-  return args.option("prompt", {
-    type: "string",
-    array: true,
-    demandOption: true,
-    describe: chalk10.bold("Path(s) to prompt artifact(s) (one per session)")
-  }).option("inference", {
-    type: "string",
-    array: true,
-    demandOption: true,
-    describe: chalk10.bold(
-      "Path(s) to inference artifact(s) (one per session)"
-    )
-  }).option("ai-response-at", {
-    type: "string",
-    array: true,
-    describe: chalk10.bold(
-      "ISO timestamp(s) for AI response (one per session, defaults to now)"
-    )
-  }).option("model", {
-    type: "string",
-    array: true,
-    describe: chalk10.bold("AI model name(s) (optional, one per session)")
-  }).option("tool-name", {
-    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: "" });
-async function getAuthenticatedGQLClientForIdeExtension() {
-  let gqlClient = new GQLClient({
-    apiKey: config5.get("apiToken") ?? "",
-    type: "apiKey"
-  });
-  gqlClient = await handleMobbLogin({
-    inGqlClient: gqlClient,
-    skipPrompts: true
-  });
-  return gqlClient;
-}
-async function uploadAiBlameHandler(args, exitOnError = true) {
-  const prompts = args.prompt || [];
-  const inferences = args.inference || [];
-  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));
-    if (exitOnError) {
-      process.exit(1);
-    }
-    throw new Error(errorMsg);
-  }
-  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-  const sessions = [];
-  for (let i = 0; i < prompts.length; i++) {
-    const promptPath = String(prompts[i]);
-    const inferencePath = String(inferences[i]);
-    try {
-      await Promise.all([
-        fsPromises3.access(promptPath),
-        fsPromises3.access(inferencePath)
-      ]);
-    } catch {
-      const errorMsg = `File not found for session ${i + 1}`;
-      console.error(chalk10.red(errorMsg));
-      if (exitOnError) {
-        process.exit(1);
-      }
-      throw new Error(errorMsg);
-    }
-    sessions.push({
-      promptFileName: path20.basename(promptPath),
-      inferenceFileName: path20.basename(inferencePath),
-      aiResponseAt: responseTimes[i] || nowIso,
-      model: models[i],
-      toolName: tools[i],
-      blameType: blameTypes[i] || "CHAT" /* Chat */
-    });
-  }
-  const authenticatedClient = await getAuthenticatedGQLClientForIdeExtension();
-  const initRes = await authenticatedClient.uploadAIBlameInferencesInitRaw({
-    sessions
-  });
-  const uploadSessions = initRes.uploadAIBlameInferencesInit?.uploadSessions ?? [];
-  if (uploadSessions.length !== sessions.length) {
-    const errorMsg = "Init failed to return expected number of sessions";
-    console.error(chalk10.red(errorMsg));
-    if (exitOnError) {
-      process.exit(1);
-    }
-    throw new Error(errorMsg);
-  }
-  for (let i = 0; i < uploadSessions.length; i++) {
-    const us = uploadSessions[i];
-    const promptPath = String(prompts[i]);
-    const inferencePath = String(inferences[i]);
-    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];
-    return {
-      aiBlameInferenceId: us.aiBlameInferenceId,
-      promptKey: us.prompt.uploadKey,
-      inferenceKey: us.inference.uploadKey,
-      aiResponseAt: s.aiResponseAt,
-      model: s.model,
-      toolName: s.toolName,
-      blameType: s.blameType
-    };
-  });
-  const finRes = await authenticatedClient.finalizeAIBlameInferencesUploadRaw({
-    sessions: finalizeSessions
-  });
-  const status = finRes?.finalizeAIBlameInferencesUpload?.status;
-  if (status !== "OK") {
-    const errorMsg = finRes?.finalizeAIBlameInferencesUpload?.error || "unknown error";
-    console.error(chalk10.red(errorMsg));
-    if (exitOnError) {
-      process.exit(1);
-    }
-    throw new Error(errorMsg);
-  }
-  console.log(chalk10.green("AI Blame uploads finalized successfully"));
-}
-
 // src/args/yargs.ts
 var parseArgs = async (args) => {
   const yargsInstance = yargs(args);
   return yargsInstance.updateStrings({
-    "Commands:": chalk11.yellow.underline.bold("Commands:"),
-    "Options:": chalk11.yellow.underline.bold("Options:"),
-    "Examples:": chalk11.yellow.underline.bold("Examples:"),
-    "Show help": chalk11.bold("Show help")
+    "Commands:": chalk12.yellow.underline.bold("Commands:"),
+    "Options:": chalk12.yellow.underline.bold("Options:"),
+    "Examples:": chalk12.yellow.underline.bold("Examples:"),
+    "Show help": chalk12.bold("Show help")
   }).usage(
-    `${chalk11.bold(
+    `${chalk12.bold(
       "\n Bugsy - Trusted, Automatic Vulnerability Fixer \u{1F575}\uFE0F\u200D\u2642\uFE0F\n\n"
-    )} ${chalk11.yellow.underline.bold("Usage:")} 
-  $0 ${chalk11.green(
+    )} ${chalk12.yellow.underline.bold("Usage:")} 
+  $0 ${chalk12.green(
       "<command>"
-    )} ${chalk11.dim("[options]")}
+    )} ${chalk12.dim("[options]")}
             `
   ).version(false).command(
     mobbCliCommand.scan,
-    chalk11.bold(
+    chalk12.bold(
       "Scan your code for vulnerabilities, get automated fixes right away."
     ),
     scanBuilder,
     scanHandler
   ).command(
     mobbCliCommand.analyze,
-    chalk11.bold(
+    chalk12.bold(
       "Provide a code repository, get automated fixes right away. You can also provide a vulnerability report to analyze or have Mobb scan the code for you."
     ),
     analyzeBuilder,
     analyzeHandler
   ).command(
     mobbCliCommand.review,
-    chalk11.bold(
+    chalk12.bold(
       "Mobb will review your github pull requests and provide comments with fixes "
     ),
     reviewBuilder,
     reviewHandler
   ).command(
     mobbCliCommand.addScmToken,
-    chalk11.bold(
+    chalk12.bold(
       "Add your SCM (Github, Gitlab, Azure DevOps) token to Mobb to enable automated fixes."
     ),
     addScmTokenBuilder,
     addScmTokenHandler
   ).command(
     mobbCliCommand.convertToSarif,
-    chalk11.bold("Convert an existing SAST report to SARIF format."),
+    chalk12.bold("Convert an existing SAST report to SARIF format."),
     convertToSarifBuilder,
     convertToSarifHandler
   ).command(
     mobbCliCommand.mcp,
-    chalk11.bold("Launch the MCP (Model Context Protocol) server."),
+    chalk12.bold("Launch the MCP (Model Context Protocol) server."),
     mcpBuilder,
     mcpHandler
   ).command(
     mobbCliCommand.uploadAiBlame,
-    chalk11.bold(
+    chalk12.bold(
       "Upload AI Blame inference artifacts (prompt + inference) and finalize them."
     ),
     uploadAiBlameBuilder,
     uploadAiBlameHandler
+  ).command(
+    mobbCliCommand.claudeCodeInstallHook,
+    chalk12.bold("Install Claude Code hooks for data collection."),
+    claudeCodeInstallHookBuilder,
+    claudeCodeInstallHookHandler
+  ).command(
+    mobbCliCommand.claudeCodeProcessHook,
+    chalk12.bold("Process Claude Code hook data and upload to backend."),
+    claudeCodeProcessHookBuilder,
+    claudeCodeProcessHookHandler
   ).example(
     "npx mobbdev@latest scan -r https://github.com/WebGoat/WebGoat",
     "Scan an existing repository"
@@ -21341,7 +21811,7 @@ var parseArgs = async (args) => {
     handler() {
       yargsInstance.showHelp();
     }
-  }).strictOptions().help("h").alias("h", "help").epilog(chalk11.bgBlue("Made with \u2764\uFE0F by Mobb")).showHelpOnFail(true).wrap(Math.min(120, yargsInstance.terminalWidth())).parse();
+  }).strictOptions().help("h").alias("h", "help").epilog(chalk12.bgBlue("Made with \u2764\uFE0F by Mobb")).showHelpOnFail(true).wrap(Math.min(120, yargsInstance.terminalWidth())).parse();
 };
 
 // src/index.ts