mobbdev 1.0.204 → 1.0.205

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"]>;
+    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;
+        rawArguments?: string | undefined;
+        accepted?: boolean | undefined;
+    }, {
+        name: string;
+        parameters: string;
+        result: string;
+        rawArguments?: string | undefined;
+        accepted?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "USER_PROMPT" | "AI_RESPONSE" | "TOOL_EXECUTION";
+    date?: Date | undefined;
+    attachedFiles?: {
+        relativePath: string;
+        startLine?: number | undefined;
+    }[] | undefined;
+    tokens?: {
+        inputCount: number;
+        outputCount: number;
+    } | undefined;
+    text?: string | undefined;
+    tool?: {
+        name: string;
+        parameters: string;
+        result: string;
+        rawArguments?: string | undefined;
+        accepted?: boolean | undefined;
+    } | undefined;
+}, {
+    type: "USER_PROMPT" | "AI_RESPONSE" | "TOOL_EXECUTION";
+    date?: Date | undefined;
+    attachedFiles?: {
+        relativePath: string;
+        startLine?: number | undefined;
+    }[] | undefined;
+    tokens?: {
+        inputCount: number;
+        outputCount: number;
+    } | undefined;
+    text?: string | undefined;
+    tool?: {
+        name: string;
+        parameters: string;
+        result: string;
+        rawArguments?: string | undefined;
+        accepted?: boolean | undefined;
+    } | undefined;
+}>;
+type PromptItem = z.infer<typeof PromptItemZ>;
+declare const PromptItemArrayZ: z.ZodArray<z.ZodObject<{
+    type: z.ZodEnum<["USER_PROMPT", "AI_RESPONSE", "TOOL_EXECUTION"]>;
+    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;
+        rawArguments?: string | undefined;
+        accepted?: boolean | undefined;
+    }, {
+        name: string;
+        parameters: string;
+        result: string;
+        rawArguments?: string | undefined;
+        accepted?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "USER_PROMPT" | "AI_RESPONSE" | "TOOL_EXECUTION";
+    date?: Date | undefined;
+    attachedFiles?: {
+        relativePath: string;
+        startLine?: number | undefined;
+    }[] | undefined;
+    tokens?: {
+        inputCount: number;
+        outputCount: number;
+    } | undefined;
+    text?: string | undefined;
+    tool?: {
+        name: string;
+        parameters: string;
+        result: string;
+        rawArguments?: string | undefined;
+        accepted?: boolean | undefined;
+    } | undefined;
+}, {
+    type: "USER_PROMPT" | "AI_RESPONSE" | "TOOL_EXECUTION";
+    date?: Date | undefined;
+    attachedFiles?: {
+        relativePath: string;
+        startLine?: number | undefined;
+    }[] | undefined;
+    tokens?: {
+        inputCount: number;
+        outputCount: number;
+    } | undefined;
+    text?: string | undefined;
+    tool?: {
+        name: string;
+        parameters: string;
+        result: string;
+        rawArguments?: string | undefined;
+        accepted?: boolean | undefined;
+    } | 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"]),
+  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

@@ -19226,9 +19226,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"]),
+  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 +19283,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 +19303,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 +19327,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 +19367,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.205",
   "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",