mobbdev 1.0.204 → 1.0.206

package/dist/args/commands/upload_ai_blame.d.mts

@@ -1,5 +1,172 @@
 import * as Yargs from 'yargs';
+import z from 'zod';
 
+declare const PromptItemZ: z.ZodObject<{
+    type: z.ZodEnum<["USER_PROMPT", "AI_RESPONSE", "TOOL_EXECUTION", "AI_THINKING"]>;
+    attachedFiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        relativePath: z.ZodString;
+        startLine: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        relativePath: string;
+        startLine?: number | undefined;
+    }, {
+        relativePath: string;
+        startLine?: number | undefined;
+    }>, "many">>;
+    tokens: z.ZodOptional<z.ZodObject<{
+        inputCount: z.ZodNumber;
+        outputCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        inputCount: number;
+        outputCount: number;
+    }, {
+        inputCount: number;
+        outputCount: number;
+    }>>;
+    text: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodDate>;
+    tool: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        parameters: z.ZodString;
+        result: z.ZodString;
+        rawArguments: z.ZodOptional<z.ZodString>;
+        accepted: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        parameters: string;
+        result: string;
+        accepted?: boolean | undefined;
+        rawArguments?: string | undefined;
+    }, {
+        name: string;
+        parameters: string;
+        result: string;
+        accepted?: boolean | undefined;
+        rawArguments?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "USER_PROMPT" | "AI_RESPONSE" | "TOOL_EXECUTION" | "AI_THINKING";
+    tool?: {
+        name: string;
+        parameters: string;
+        result: string;
+        accepted?: boolean | undefined;
+        rawArguments?: string | undefined;
+    } | undefined;
+    date?: Date | undefined;
+    text?: string | undefined;
+    attachedFiles?: {
+        relativePath: string;
+        startLine?: number | undefined;
+    }[] | undefined;
+    tokens?: {
+        inputCount: number;
+        outputCount: number;
+    } | undefined;
+}, {
+    type: "USER_PROMPT" | "AI_RESPONSE" | "TOOL_EXECUTION" | "AI_THINKING";
+    tool?: {
+        name: string;
+        parameters: string;
+        result: string;
+        accepted?: boolean | undefined;
+        rawArguments?: string | undefined;
+    } | undefined;
+    date?: Date | undefined;
+    text?: string | undefined;
+    attachedFiles?: {
+        relativePath: string;
+        startLine?: number | undefined;
+    }[] | undefined;
+    tokens?: {
+        inputCount: number;
+        outputCount: number;
+    } | undefined;
+}>;
+type PromptItem = z.infer<typeof PromptItemZ>;
+declare const PromptItemArrayZ: z.ZodArray<z.ZodObject<{
+    type: z.ZodEnum<["USER_PROMPT", "AI_RESPONSE", "TOOL_EXECUTION", "AI_THINKING"]>;
+    attachedFiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        relativePath: z.ZodString;
+        startLine: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        relativePath: string;
+        startLine?: number | undefined;
+    }, {
+        relativePath: string;
+        startLine?: number | undefined;
+    }>, "many">>;
+    tokens: z.ZodOptional<z.ZodObject<{
+        inputCount: z.ZodNumber;
+        outputCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        inputCount: number;
+        outputCount: number;
+    }, {
+        inputCount: number;
+        outputCount: number;
+    }>>;
+    text: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodDate>;
+    tool: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        parameters: z.ZodString;
+        result: z.ZodString;
+        rawArguments: z.ZodOptional<z.ZodString>;
+        accepted: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        parameters: string;
+        result: string;
+        accepted?: boolean | undefined;
+        rawArguments?: string | undefined;
+    }, {
+        name: string;
+        parameters: string;
+        result: string;
+        accepted?: boolean | undefined;
+        rawArguments?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "USER_PROMPT" | "AI_RESPONSE" | "TOOL_EXECUTION" | "AI_THINKING";
+    tool?: {
+        name: string;
+        parameters: string;
+        result: string;
+        accepted?: boolean | undefined;
+        rawArguments?: string | undefined;
+    } | undefined;
+    date?: Date | undefined;
+    text?: string | undefined;
+    attachedFiles?: {
+        relativePath: string;
+        startLine?: number | undefined;
+    }[] | undefined;
+    tokens?: {
+        inputCount: number;
+        outputCount: number;
+    } | undefined;
+}, {
+    type: "USER_PROMPT" | "AI_RESPONSE" | "TOOL_EXECUTION" | "AI_THINKING";
+    tool?: {
+        name: string;
+        parameters: string;
+        result: string;
+        accepted?: boolean | undefined;
+        rawArguments?: string | undefined;
+    } | undefined;
+    date?: Date | undefined;
+    text?: string | undefined;
+    attachedFiles?: {
+        relativePath: string;
+        startLine?: number | undefined;
+    }[] | undefined;
+    tokens?: {
+        inputCount: number;
+        outputCount: number;
+    } | undefined;
+}>, "many">;
+type PromptItemArray = z.infer<typeof PromptItemArrayZ>;
 type UploadAiBlameOptions = {
     prompt: string[];
     inference: string[];
@@ -10,6 +177,13 @@ type UploadAiBlameOptions = {
     'tool-name'?: string[];
 };
 declare function uploadAiBlameBuilder(args: Yargs.Argv<unknown>): Yargs.Argv<UploadAiBlameOptions>;
-declare function uploadAiBlameHandler(args: UploadAiBlameOptions): Promise<void>;
+declare function uploadAiBlameHandlerFromExtension(args: {
+    prompts: PromptItemArray;
+    inference: string;
+    model: string;
+    tool: string;
+    responseTime: string;
+}): Promise<void>;
+declare function uploadAiBlameHandler(args: UploadAiBlameOptions, exitOnError?: boolean): Promise<void>;
 
-export { type UploadAiBlameOptions, uploadAiBlameBuilder, uploadAiBlameHandler };
+export { type PromptItem, type PromptItemArray, type UploadAiBlameOptions, uploadAiBlameBuilder, uploadAiBlameHandler, uploadAiBlameHandlerFromExtension };

package/dist/args/commands/upload_ai_blame.mjs

@@ -92,9 +92,11 @@ var init_GitService = __esm({
 });
 
 // src/args/commands/upload_ai_blame.ts
-import fs5 from "fs/promises";
+import fsPromises2 from "fs/promises";
 import path6 from "path";
 import chalk2 from "chalk";
+import { withFile } from "tmp-promise";
+import z27 from "zod";
 
 // src/features/analysis/upload-file.ts
 import Debug7 from "debug";
@@ -5560,6 +5562,29 @@ async function createAuthenticatedMcpGQLClient({
 }
 
 // src/args/commands/upload_ai_blame.ts
+var PromptItemZ = z27.object({
+  type: z27.enum(["USER_PROMPT", "AI_RESPONSE", "TOOL_EXECUTION", "AI_THINKING"]),
+  attachedFiles: z27.array(
+    z27.object({
+      relativePath: z27.string(),
+      startLine: z27.number().optional()
+    })
+  ).optional(),
+  tokens: z27.object({
+    inputCount: z27.number(),
+    outputCount: z27.number()
+  }).optional(),
+  text: z27.string().optional(),
+  date: z27.date().optional(),
+  tool: z27.object({
+    name: z27.string(),
+    parameters: z27.string(),
+    result: z27.string(),
+    rawArguments: z27.string().optional(),
+    accepted: z27.boolean().optional()
+  }).optional()
+});
+var PromptItemArrayZ = z27.array(PromptItemZ);
 function uploadAiBlameBuilder(args) {
   return args.option("prompt", {
     type: "string",
@@ -5589,17 +5614,44 @@ function uploadAiBlameBuilder(args) {
     describe: chalk2.bold("Tool/IDE name(s) (optional, one per session)")
   }).strict();
 }
-async function uploadAiBlameHandler(args) {
+async function uploadAiBlameHandlerFromExtension(args) {
+  const uploadArgs = {
+    prompt: [],
+    inference: [],
+    model: [],
+    toolName: [],
+    aiResponseAt: []
+  };
+  await withFile(async (promptFile) => {
+    await fsPromises2.writeFile(
+      promptFile.path,
+      JSON.stringify(args.prompts, null, 2),
+      "utf-8"
+    );
+    uploadArgs.prompt.push(promptFile.path);
+    await withFile(async (inferenceFile) => {
+      await fsPromises2.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);
+      await uploadAiBlameHandler(uploadArgs, false);
+    });
+  });
+}
+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"] || [];
   if (prompts.length !== inferences.length) {
-    console.error(
-      chalk2.red("prompt and inference must have the same number of entries")
-    );
-    process.exit(1);
+    const errorMsg = "prompt and inference must have the same number of entries";
+    console.error(chalk2.red(errorMsg));
+    if (exitOnError) {
+      process.exit(1);
+    }
+    throw new Error(errorMsg);
   }
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   const sessions = [];
@@ -5607,10 +5659,17 @@ async function uploadAiBlameHandler(args) {
     const promptPath = String(prompts[i]);
     const inferencePath = String(inferences[i]);
     try {
-      await Promise.all([fs5.access(promptPath), fs5.access(inferencePath)]);
+      await Promise.all([
+        fsPromises2.access(promptPath),
+        fsPromises2.access(inferencePath)
+      ]);
     } catch {
-      console.error(chalk2.red(`File not found for session ${i + 1}`));
-      process.exit(1);
+      const errorMsg = `File not found for session ${i + 1}`;
+      console.error(chalk2.red(errorMsg));
+      if (exitOnError) {
+        process.exit(1);
+      }
+      throw new Error(errorMsg);
     }
     sessions.push({
       promptFileName: path6.basename(promptPath),
@@ -5624,10 +5683,12 @@ async function uploadAiBlameHandler(args) {
   const initRes = await gqlClient.uploadAIBlameInferencesInitRaw({ sessions });
   const uploadSessions = initRes.uploadAIBlameInferencesInit?.uploadSessions ?? [];
   if (uploadSessions.length !== sessions.length) {
-    console.error(
-      chalk2.red("Init failed to return expected number of sessions")
-    );
-    process.exit(1);
+    const errorMsg = "Init failed to return expected number of sessions";
+    console.error(chalk2.red(errorMsg));
+    if (exitOnError) {
+      process.exit(1);
+    }
+    throw new Error(errorMsg);
   }
   for (let i = 0; i < uploadSessions.length; i++) {
     const us = uploadSessions[i];
@@ -5662,16 +5723,17 @@ async function uploadAiBlameHandler(args) {
   });
   const status = finRes?.finalizeAIBlameInferencesUpload?.status;
   if (status !== "OK") {
-    console.error(
-      chalk2.red(
-        `Finalize failed: ${finRes?.finalizeAIBlameInferencesUpload?.error || "unknown error"}`
-      )
-    );
-    process.exit(1);
+    const errorMsg = finRes?.finalizeAIBlameInferencesUpload?.error || "unknown error";
+    console.error(chalk2.red(errorMsg));
+    if (exitOnError) {
+      process.exit(1);
+    }
+    throw new Error(errorMsg);
   }
   console.log(chalk2.green("AI Blame uploads finalized successfully"));
 }
 export {
   uploadAiBlameBuilder,
-  uploadAiBlameHandler
+  uploadAiBlameHandler,
+  uploadAiBlameHandlerFromExtension
 };

package/dist/index.mjs

@@ -7354,6 +7354,7 @@ var GET_BLAME_DOCUMENT = `
               blame(path: $path) {
                 ranges {
                   commit {
+                    oid
                     author {
                       user {
                         name
@@ -7368,7 +7369,7 @@ var GET_BLAME_DOCUMENT = `
                 }
               }
             }
-            
+
           }
         }
       }
@@ -7776,6 +7777,7 @@ function getGithubSdk(params = {}) {
         (range) => ({
           startingLine: range.startingLine,
           endingLine: range.endingLine,
+          commitSha: range.commit.oid,
           email: range.commit.author.user?.email || "",
           name: range.commit.author.user?.name || "",
           login: range.commit.author.user?.login || ""
@@ -7925,6 +7927,14 @@ function getGithubSdk(params = {}) {
         direction: "desc",
         per_page: 100
       });
+    },
+    async listPRFiles(params2) {
+      return octokit.rest.pulls.listFiles({
+        owner: params2.owner,
+        repo: params2.repo,
+        pull_number: params2.pull_number,
+        per_page: 100
+      });
     }
   };
 }
@@ -8207,24 +8217,21 @@ var GithubSCMLib = class extends SCMLib {
     this._validateAccessTokenAndUrl();
     const { owner, repo } = parseGithubOwnerAndRepo(this.url);
     const prNumber = Number(submitRequestId);
-    const prRes = await this.githubSdk.getPr({
-      owner,
-      repo,
-      pull_number: prNumber
-    });
-    const prDiff = await this.getPrDiff({ pull_number: prNumber });
-    const commitsRes = await this.githubSdk.getPrCommits({
-      owner,
-      repo,
-      pull_number: prNumber
-    });
-    const commits = [];
-    for (const commit of commitsRes.data) {
-      const commitDiff = await this.getCommitDiff(commit.sha);
-      commits.push(commitDiff);
-    }
+    const [prRes, commitsRes, filesRes] = await Promise.all([
+      this.githubSdk.getPr({ owner, repo, pull_number: prNumber }),
+      this.githubSdk.getPrCommits({ owner, repo, pull_number: prNumber }),
+      this.githubSdk.listPRFiles({ owner, repo, pull_number: prNumber })
+    ]);
     const pr = prRes.data;
-    const diffLines = this._calculateDiffLineAttributions(prDiff, commits);
+    const prDiff = await this.getPrDiff({ pull_number: prNumber });
+    const commits = await Promise.all(
+      commitsRes.data.map((commit) => this.getCommitDiff(commit.sha))
+    );
+    const diffLines = await this._attributeLinesViaBlame(
+      pr.head.ref,
+      filesRes.data,
+      commits
+    );
     return {
       diff: prDiff,
       createdAt: new Date(pr.created_at),
@@ -8344,18 +8351,15 @@ var GithubSCMLib = class extends SCMLib {
       return { added: 0, removed: 0 };
     }
   }
-  _calculateDiffLineAttributions(prDiff, commits) {
-    const attributions = [];
-    const prDiffLines = prDiff.split("\n");
-    let currentFile = "";
+  /**
+   * Optimized helper to parse added line numbers from a unified diff patch
+   * Single-pass parsing for minimal CPU usage
+   */
+  _parseAddedLinesFromPatch(patch) {
+    const addedLines = [];
+    const lines = patch.split("\n");
     let currentLineNumber = 0;
-    for (const line of prDiffLines) {
-      if (line.startsWith("+++")) {
-        const match = line.match(/^\+\+\+ b\/(.+)$/);
-        currentFile = match?.[1] || "";
-        currentLineNumber = 0;
-        continue;
-      }
+    for (const line of lines) {
       if (line.startsWith("@@")) {
         const match = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)/);
         if (match?.[1]) {
@@ -8364,122 +8368,57 @@ var GithubSCMLib = class extends SCMLib {
         continue;
       }
       if (line.startsWith("+") && !line.startsWith("+++")) {
-        const commitSha = this._findCommitForLine(
-          currentFile,
-          currentLineNumber,
-          line.substring(1),
-          // Remove the '+' prefix
-          commits
-        );
-        if (commitSha && currentFile) {
-          attributions.push({
-            file: currentFile,
-            line: currentLineNumber,
-            commitSha
-          });
-        }
+        addedLines.push(currentLineNumber);
         currentLineNumber++;
       } else if (!line.startsWith("-")) {
         currentLineNumber++;
       }
     }
-    return attributions;
+    return addedLines;
   }
-  _findCommitForLine(file, lineNumber, lineContent, commits) {
-    const normalizedContent = lineContent.trim();
-    for (let i = commits.length - 1; i >= 0; i--) {
-      const commit = commits[i];
-      if (!commit) {
-        continue;
-      }
-      const commitLines = commit.diff.split("\n");
-      let commitCurrentFile = "";
-      for (const commitLine of commitLines) {
-        if (commitLine.startsWith("+++")) {
-          const match = commitLine.match(/^\+\+\+ b\/(.+)$/);
-          commitCurrentFile = match?.[1] || "";
-          continue;
-        }
-        if (commitLine.startsWith("@@")) {
+  /**
+   * Attribute lines in a single file to their commits using blame
+   */
+  async _attributeFileLines(file, headRef, prCommitShas) {
+    try {
+      const blame = await this.getRepoBlameRanges(headRef, file.filename);
+      const addedLines = this._parseAddedLinesFromPatch(file.patch);
+      const addedLinesSet = new Set(addedLines);
+      const fileAttributions = [];
+      for (const blameRange of blame) {
+        if (!prCommitShas.has(blameRange.commitSha)) {
           continue;
         }
-        if (commitCurrentFile === file && commitLine.startsWith("+") && !commitLine.startsWith("+++")) {
-          const commitLineContent = commitLine.substring(1).trim();
-          if (commitLineContent === normalizedContent) {
-            return commit.commitSha;
+        for (let lineNum = blameRange.startingLine; lineNum <= blameRange.endingLine; lineNum++) {
+          if (addedLinesSet.has(lineNum)) {
+            fileAttributions.push({
+              file: file.filename,
+              line: lineNum,
+              commitSha: blameRange.commitSha
+            });
           }
         }
       }
+      return fileAttributions;
+    } catch (error) {
+      return [];
     }
-    for (let i = commits.length - 1; i >= 0; i--) {
-      const commit = commits[i];
-      if (!commit) {
-        continue;
-      }
-      const addedLinesInFile = this._getAddedLinesFromCommit(commit, file);
-      for (const { lineNum, content } of addedLinesInFile) {
-        if (Math.abs(lineNum - lineNumber) <= 10 && this._contentSimilarity(content, normalizedContent) > 0.9) {
-          return commit.commitSha;
-        }
-      }
-    }
-    const lastCommit = commits[commits.length - 1];
-    return lastCommit ? lastCommit.commitSha : null;
-  }
-  _getAddedLinesFromCommit(commit, targetFile) {
-    const addedLines = [];
-    const commitLines = commit.diff.split("\n");
-    let currentFile = "";
-    let currentLineNumber = 0;
-    for (const line of commitLines) {
-      if (line.startsWith("+++")) {
-        const match = line.match(/^\+\+\+ b\/(.+)$/);
-        currentFile = match?.[1] || "";
-        currentLineNumber = 0;
-        continue;
-      }
-      if (line.startsWith("@@")) {
-        const match = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)/);
-        if (match?.[1]) {
-          currentLineNumber = parseInt(match[1], 10);
-        }
-        continue;
-      }
-      if (currentFile === targetFile && line.startsWith("+") && !line.startsWith("+++")) {
-        addedLines.push({
-          lineNum: currentLineNumber,
-          content: line.substring(1).trim()
-        });
-        currentLineNumber++;
-      } else if (!line.startsWith("-")) {
-        if (currentFile === targetFile) {
-          currentLineNumber++;
-        }
-      }
-    }
-    return addedLines;
   }
-  _contentSimilarity(content1, content2) {
-    if (content1 === content2) {
-      return 1;
-    }
-    const normalized1 = content1.replace(/\s+/g, " ");
-    const normalized2 = content2.replace(/\s+/g, " ");
-    if (normalized1 === normalized2) {
-      return 0.95;
-    }
-    const longer = normalized1.length > normalized2.length ? normalized1 : normalized2;
-    const shorter = normalized1.length > normalized2.length ? normalized2 : normalized1;
-    if (longer.length === 0) {
-      return 1;
-    }
-    if (longer.includes(shorter)) {
-      return shorter.length / longer.length;
-    }
-    const set1 = new Set(normalized1.split(""));
-    const set2 = new Set(normalized2.split(""));
-    const intersection = new Set([...set1].filter((x) => set2.has(x)));
-    return intersection.size / Math.max(set1.size, set2.size);
+  /**
+   * Optimized helper to attribute PR lines to commits using blame API
+   * Parallel blame queries for minimal API call time
+   */
+  async _attributeLinesViaBlame(headRef, changedFiles, prCommits) {
+    const prCommitShas = new Set(prCommits.map((c) => c.commitSha));
+    const filesWithAdditions = changedFiles.filter(
+      (file) => file.patch?.includes("\n+")
+    );
+    const attributions = await Promise.all(
+      filesWithAdditions.map(
+        (file) => this._attributeFileLines(file, headRef, prCommitShas)
+      )
+    );
+    return attributions.flat();
   }
 };
 
@@ -8828,6 +8767,7 @@ async function getGitlabBlameRanges({ ref, gitlabUrl, path: path17 }, options) {
     return {
       startingLine: oldLineNumber,
       endingLine: lineNumber - 1,
+      commitSha: range.commit.id,
       login: range.commit.author_email,
       email: range.commit.author_email,
       name: range.commit.author_name
@@ -19226,9 +19166,34 @@ async function addScmTokenHandler(args) {
 }
 
 // src/args/commands/upload_ai_blame.ts
-import fs18 from "fs/promises";
+import fsPromises3 from "fs/promises";
 import path16 from "path";
 import chalk10 from "chalk";
+import { withFile } from "tmp-promise";
+import z38 from "zod";
+var PromptItemZ = z38.object({
+  type: z38.enum(["USER_PROMPT", "AI_RESPONSE", "TOOL_EXECUTION", "AI_THINKING"]),
+  attachedFiles: z38.array(
+    z38.object({
+      relativePath: z38.string(),
+      startLine: z38.number().optional()
+    })
+  ).optional(),
+  tokens: z38.object({
+    inputCount: z38.number(),
+    outputCount: z38.number()
+  }).optional(),
+  text: z38.string().optional(),
+  date: z38.date().optional(),
+  tool: z38.object({
+    name: z38.string(),
+    parameters: z38.string(),
+    result: z38.string(),
+    rawArguments: z38.string().optional(),
+    accepted: z38.boolean().optional()
+  }).optional()
+});
+var PromptItemArrayZ = z38.array(PromptItemZ);
 function uploadAiBlameBuilder(args) {
   return args.option("prompt", {
     type: "string",
@@ -19258,17 +19223,19 @@ function uploadAiBlameBuilder(args) {
     describe: chalk10.bold("Tool/IDE name(s) (optional, one per session)")
   }).strict();
 }
-async function uploadAiBlameHandler(args) {
+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"] || [];
   if (prompts.length !== inferences.length) {
-    console.error(
-      chalk10.red("prompt and inference must have the same number of entries")
-    );
-    process.exit(1);
+    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 = [];
@@ -19276,10 +19243,17 @@ async function uploadAiBlameHandler(args) {
     const promptPath = String(prompts[i]);
     const inferencePath = String(inferences[i]);
     try {
-      await Promise.all([fs18.access(promptPath), fs18.access(inferencePath)]);
+      await Promise.all([
+        fsPromises3.access(promptPath),
+        fsPromises3.access(inferencePath)
+      ]);
     } catch {
-      console.error(chalk10.red(`File not found for session ${i + 1}`));
-      process.exit(1);
+      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: path16.basename(promptPath),
@@ -19293,10 +19267,12 @@ async function uploadAiBlameHandler(args) {
   const initRes = await gqlClient.uploadAIBlameInferencesInitRaw({ sessions });
   const uploadSessions = initRes.uploadAIBlameInferencesInit?.uploadSessions ?? [];
   if (uploadSessions.length !== sessions.length) {
-    console.error(
-      chalk10.red("Init failed to return expected number of sessions")
-    );
-    process.exit(1);
+    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];
@@ -19331,12 +19307,12 @@ async function uploadAiBlameHandler(args) {
   });
   const status = finRes?.finalizeAIBlameInferencesUpload?.status;
   if (status !== "OK") {
-    console.error(
-      chalk10.red(
-        `Finalize failed: ${finRes?.finalizeAIBlameInferencesUpload?.error || "unknown error"}`
-      )
-    );
-    process.exit(1);
+    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"));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobbdev",
-  "version": "1.0.204",
+  "version": "1.0.206",
   "description": "Automated secure code remediation tool",
   "repository": "git+https://github.com/mobb-dev/bugsy.git",
   "main": "dist/index.mjs",
@@ -92,6 +92,7 @@
     "snyk": "1.1300.0",
     "tar": "6.2.1",
     "tmp": "0.2.5",
+    "tmp-promise": "3.0.3",
     "undici": "6.21.3",
     "uuid": "11.1.0",
     "ws": "8.18.3",