mobbdev 1.0.203 → 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,62 +92,16 @@ 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";
 import fetch3, { File, fileFrom, FormData } from "node-fetch";
 
-// src/utils/dirname.ts
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-function getModuleRootDir() {
-  let manifestDir = getDirName();
-  for (let i = 0; i < 10; i++) {
-    const manifestPath = path.join(manifestDir, "package.json");
-    if (fs.existsSync(manifestPath)) {
-      return manifestDir;
-    }
-    manifestDir = path.join(manifestDir, "..");
-  }
-  throw new Error("Cannot locate package.json file");
-}
-function getDirName() {
-  return path.dirname(fileURLToPath(import.meta.url));
-}
-
-// src/utils/keypress.ts
-import readline from "readline";
-
-// src/utils/spinner.ts
-import {
-  createSpinner as _createSpinner
-} from "nanospinner";
-
-// src/utils/check_node_version.ts
-import fs2 from "fs";
-import path2 from "path";
-import semver from "semver";
-function getPackageJson() {
-  return JSON.parse(
-    fs2.readFileSync(path2.join(getModuleRootDir(), "package.json"), "utf8")
-  );
-}
-var packageJson = getPackageJson();
-if (!semver.satisfies(process.version, packageJson.engines.node)) {
-  console.error(
-    `
-\u26A0\uFE0F ${packageJson.name} requires node version ${packageJson.engines.node}, but running ${process.version}.`
-  );
-  process.exit(1);
-}
-
-// src/utils/index.ts
-var sleep = (ms = 2e3) => new Promise((r) => setTimeout(r, ms));
-
 // src/features/analysis/graphql/gql.ts
 import fetchOrig from "cross-fetch";
 import Debug6 from "debug";
@@ -157,7 +111,7 @@ import { HttpsProxyAgent as HttpsProxyAgent2 } from "https-proxy-agent";
 import { v4 as uuidv4 } from "uuid";
 
 // src/constants.ts
-import path3 from "path";
+import path2 from "path";
 import chalk from "chalk";
 import Debug from "debug";
 import * as dotenv from "dotenv";
@@ -2098,9 +2052,48 @@ var ScmType = /* @__PURE__ */ ((ScmType2) => {
   return ScmType2;
 })(ScmType || {});
 
+// src/utils/dirname.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function getModuleRootDir() {
+  let manifestDir = getDirName();
+  for (let i = 0; i < 10; i++) {
+    const manifestPath = path.join(manifestDir, "package.json");
+    if (fs.existsSync(manifestPath)) {
+      return manifestDir;
+    }
+    manifestDir = path.join(manifestDir, "..");
+  }
+  throw new Error("Cannot locate package.json file");
+}
+function getDirName() {
+  if (typeof __filename !== "undefined") {
+    return path.dirname(__filename);
+  } else {
+    try {
+      const getImportMetaUrl = new Function("return import.meta.url");
+      const importMetaUrl = getImportMetaUrl();
+      return path.dirname(fileURLToPath(importMetaUrl));
+    } catch (e) {
+      try {
+        const err = new Error();
+        const stack = err.stack || "";
+        const match = stack.match(/file:\/\/[^\s)]+/);
+        if (match) {
+          const fileUrl = match[0];
+          return path.dirname(fileURLToPath(fileUrl));
+        }
+      } catch {
+      }
+      throw new Error("Unable to determine directory name in this environment");
+    }
+  }
+}
+
 // src/constants.ts
 var debug = Debug("mobbdev:constants");
-dotenv.config({ path: path3.join(getModuleRootDir(), ".env") });
+dotenv.config({ path: path2.join(getModuleRootDir(), ".env") });
 var scmFriendlyText = {
   ["Ado" /* Ado */]: "Azure DevOps",
   ["Bitbucket" /* Bitbucket */]: "Bitbucket",
@@ -2184,6 +2177,35 @@ var FailedToGetApiTokenError = class extends Error {
   }
 };
 
+// src/utils/keypress.ts
+import readline from "readline";
+
+// src/utils/spinner.ts
+import {
+  createSpinner as _createSpinner
+} from "nanospinner";
+
+// src/utils/check_node_version.ts
+import fs2 from "fs";
+import path3 from "path";
+import semver from "semver";
+function getPackageJson() {
+  return JSON.parse(
+    fs2.readFileSync(path3.join(getModuleRootDir(), "package.json"), "utf8")
+  );
+}
+var packageJson = getPackageJson();
+if (!semver.satisfies(process.version, packageJson.engines.node)) {
+  console.error(
+    `
+\u26A0\uFE0F ${packageJson.name} requires node version ${packageJson.engines.node}, but running ${process.version}.`
+  );
+  process.exit(1);
+}
+
+// src/utils/index.ts
+var sleep = (ms = 2e3) => new Promise((r) => setTimeout(r, ms));
+
 // src/features/analysis/scm/utils/index.ts
 import { z as z15 } from "zod";
 
@@ -4314,7 +4336,11 @@ function createWSClient(options) {
   );
   const CustomWebSocket = class extends WebSocket {
     constructor(address, protocols) {
-      super(address, protocols, proxy ? { agent: proxy } : void 0);
+      super(
+        address,
+        protocols,
+        proxy ? { agent: proxy } : void 0
+      );
     }
   };
   return createClient({
@@ -4809,8 +4835,8 @@ var GetLatestReportByRepoUrlResponseSchema = z26.object({
 });
 
 // src/mcp/services/ConfigStoreService.ts
-init_configs();
 import Configstore2 from "configstore";
+init_configs();
 function createConfigStore(defaultValues = { apiToken: "" }) {
   const API_URL2 = process.env["API_URL"] || MCP_DEFAULT_API_URL;
   let domain = "";
@@ -4834,8 +4860,8 @@ var configStore = getConfigStore();
 // src/mcp/services/McpAuthService.ts
 import crypto from "crypto";
 import os from "os";
-init_configs();
 import open from "open";
+init_configs();
 var McpAuthService = class {
   constructor(client) {
     __publicField(this, "client");
@@ -5536,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",
@@ -5565,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 = [];
@@ -5583,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),
@@ -5600,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];
@@ -5638,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
 };