mobbdev 1.0.189 → 1.0.190

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.mjs

@@ -1323,10 +1323,10 @@ import Debug20 from "debug";
 import { hideBin } from "yargs/helpers";
 
 // src/args/commands/convert_to_sarif.ts
-import fs6 from "fs";
+import fs7 from "fs";
 
 // src/commands/convert_to_sarif.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import path5 from "path";
 
 // src/commands/fpr_stream_parser.ts
@@ -9087,6 +9087,7 @@ __export(utils_exports, {
   CliError: () => CliError,
   Spinner: () => Spinner,
   getDirName: () => getDirName,
+  getModuleRootDir: () => getModuleRootDir,
   getTopLevelDirName: () => getTopLevelDirName,
   keypress: () => keypress,
   packageJson: () => packageJson,
@@ -9094,8 +9095,20 @@ __export(utils_exports, {
 });
 
 // src/utils/dirname.ts
+import fs4 from "fs";
 import path3 from "path";
 import { fileURLToPath } from "url";
+function getModuleRootDir() {
+  let manifestDir = getDirName();
+  for (let i = 0; i < 10; i++) {
+    const manifestPath = path3.join(manifestDir, "package.json");
+    if (fs4.existsSync(manifestPath)) {
+      return manifestDir;
+    }
+    manifestDir = path3.join(manifestDir, "..");
+  }
+  throw new Error("Cannot locate package.json file");
+}
 function getDirName() {
   return path3.dirname(fileURLToPath(import.meta.url));
 }
@@ -9163,15 +9176,13 @@ function Spinner({ ci = false } = {}) {
 }
 
 // src/utils/check_node_version.ts
-import fs4 from "fs";
+import fs5 from "fs";
 import path4 from "path";
 import semver from "semver";
 function getPackageJson() {
-  let manifestPath = path4.join(getDirName(), "../package.json");
-  if (!fs4.existsSync(manifestPath)) {
-    manifestPath = path4.join(getDirName(), "../../package.json");
-  }
-  return JSON.parse(fs4.readFileSync(manifestPath, "utf8"));
+  return JSON.parse(
+    fs5.readFileSync(path4.join(getModuleRootDir(), "package.json"), "utf8")
+  );
 }
 var packageJson = getPackageJson();
 if (!semver.satisfies(process.version, packageJson.engines.node)) {
@@ -9237,7 +9248,7 @@ async function convertFprToSarif(inputFilePath, outputFilePath, codePathPatterns
       await auditXmlSaxParser.parse();
     }
     await zipIn.close();
-    const writer = fs5.createWriteStream(outputFilePath);
+    const writer = fs6.createWriteStream(outputFilePath);
     writer.write(`{
   "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
   "version": "2.1.0",
@@ -9343,14 +9354,12 @@ import chalk2 from "chalk";
 
 // src/constants.ts
 import path6 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk from "chalk";
 import Debug4 from "debug";
 import * as dotenv from "dotenv";
 import { z as z24 } from "zod";
 var debug5 = Debug4("mobbdev:constants");
-var __dirname = path6.dirname(fileURLToPath2(import.meta.url));
-dotenv.config({ path: path6.join(__dirname, "../.env") });
+dotenv.config({ path: path6.join(getModuleRootDir(), ".env") });
 var scmFriendlyText = {
   ["Ado" /* Ado */]: "Azure DevOps",
   ["Bitbucket" /* Bitbucket */]: "Bitbucket",
@@ -9571,7 +9580,7 @@ function convertToSarifBuilder(args) {
   ).help().demandOption(["input-file-path", "input-file-format", "output-file-path"]);
 }
 async function validateConvertToSarifOptions(args) {
-  if (!fs6.existsSync(args.inputFilePath)) {
+  if (!fs7.existsSync(args.inputFilePath)) {
     throw new CliError(
       "\nError: --input-file-path flag should point to an existing file"
     );
@@ -9605,14 +9614,14 @@ import chalk11 from "chalk";
 import yargs from "yargs/yargs";
 
 // src/args/commands/analyze.ts
-import fs9 from "fs";
+import fs10 from "fs";
 
 // src/commands/index.ts
 import crypto from "crypto";
 import os from "os";
 
 // src/features/analysis/index.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import fsPromises2 from "fs/promises";
 import path9 from "path";
 import { env as env2 } from "process";
@@ -10892,7 +10901,7 @@ var GQLClient = class {
 
 // src/features/analysis/pack.ts
 init_configs();
-import fs7 from "fs";
+import fs8 from "fs";
 import path7 from "path";
 import AdmZip from "adm-zip";
 import Debug13 from "debug";
@@ -10969,11 +10978,11 @@ async function pack(srcDirPath, vulnFiles, isIncludeAllFiles = false) {
         continue;
       }
     }
-    if (fs7.lstatSync(absFilepath).size > MCP_MAX_FILE_SIZE) {
+    if (fs8.lstatSync(absFilepath).size > MCP_MAX_FILE_SIZE) {
       debug14("ignoring %s because the size is > 5MB", filepath);
       continue;
     }
-    const data = git ? await git.showBuffer([`HEAD:./${filepath}`]) : fs7.readFileSync(absFilepath);
+    const data = git ? await git.showBuffer([`HEAD:./${filepath}`]) : fs8.readFileSync(absFilepath);
     if (isBinary2(null, data)) {
       debug14("ignoring %s because is seems to be a binary file", filepath);
       continue;
@@ -11397,13 +11406,13 @@ async function downloadRepo({
     repoSpinner.error({ text: "\u{1F4BE} Repo download failed" });
     throw new Error(`Can't access ${chalk5.bold(repoUrl)}`);
   }
-  const fileWriterStream = fs8.createWriteStream(zipFilePath);
+  const fileWriterStream = fs9.createWriteStream(zipFilePath);
   if (!response.body) {
     throw new Error("Response body is empty");
   }
   await pipeline(response.body, fileWriterStream);
   await extract(zipFilePath, { dir: dirname });
-  const repoRoot = fs8.readdirSync(dirname, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name)[0];
+  const repoRoot = fs9.readdirSync(dirname, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name)[0];
   if (!repoRoot) {
     throw new Error("Repo root not found");
   }
@@ -12332,7 +12341,7 @@ function analyzeBuilder(yargs2) {
   ).help();
 }
 function validateAnalyzeOptions(argv) {
-  if (argv.f && !fs9.existsSync(argv.f)) {
+  if (argv.f && !fs10.existsSync(argv.f)) {
     throw new CliError(`
 Can't access ${chalk8.bold(argv.f)}`);
   }
@@ -13393,7 +13402,7 @@ async function createAuthenticatedMcpGQLClient({
 
 // src/mcp/services/McpUsageService/host.ts
 import { execSync } from "child_process";
-import fs10 from "fs";
+import fs11 from "fs";
 import os3 from "os";
 import path11 from "path";
 var IDEs = ["cursor", "windsurf", "webstorm", "vscode", "claude"];
@@ -13412,15 +13421,15 @@ var getClaudeWorkspacePaths = () => {
   const home = os3.homedir();
   const claudeIdePath = path11.join(home, ".claude", "ide");
   const workspacePaths = [];
-  if (!fs10.existsSync(claudeIdePath)) {
+  if (!fs11.existsSync(claudeIdePath)) {
     return workspacePaths;
   }
   try {
-    const lockFiles = fs10.readdirSync(claudeIdePath).filter((file) => file.endsWith(".lock"));
+    const lockFiles = fs11.readdirSync(claudeIdePath).filter((file) => file.endsWith(".lock"));
     for (const lockFile of lockFiles) {
       const lockFilePath = path11.join(claudeIdePath, lockFile);
       try {
-        const lockContent = JSON.parse(fs10.readFileSync(lockFilePath, "utf8"));
+        const lockContent = JSON.parse(fs11.readFileSync(lockFilePath, "utf8"));
         if (lockContent.workspaceFolders && Array.isArray(lockContent.workspaceFolders)) {
           workspacePaths.push(...lockContent.workspaceFolders);
         }
@@ -13486,9 +13495,9 @@ var getMCPConfigPaths = (hostName) => {
   }
 };
 var readConfigFile = (filePath) => {
-  if (!fs10.existsSync(filePath)) return null;
+  if (!fs11.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs10.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs11.readFileSync(filePath, "utf8"));
   } catch (error) {
     logWarn(`[UsageService] Failed to read MCP config: ${filePath}`);
     return null;
@@ -14472,7 +14481,7 @@ var McpServer = class {
 import { z as z34 } from "zod";
 
 // src/mcp/services/PathValidation.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import path12 from "path";
 async function validatePath(inputPath) {
   logDebug("Validating MCP path", { inputPath });
@@ -14532,7 +14541,7 @@ async function validatePath(inputPath) {
   logDebug("Path validation successful", { inputPath });
   logDebug("Checking path existence", { inputPath });
   try {
-    await fs11.promises.access(inputPath);
+    await fs12.promises.access(inputPath);
     logDebug("Path exists and is accessible", { inputPath });
     WorkspaceService.setKnownWorkspacePath(inputPath);
     logDebug("Stored validated path in WorkspaceService", { inputPath });
@@ -15154,7 +15163,7 @@ If you wish to scan files that were recently changed in your git history call th
 init_FileUtils();
 init_GitService();
 init_configs();
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 import nodePath from "path";
 var getLocalFiles = async ({
   path: path17,
@@ -15172,7 +15181,7 @@ var getLocalFiles = async ({
     scanRecentlyChangedFiles
   });
   try {
-    const resolvedRepoPath = await fs12.realpath(path17);
+    const resolvedRepoPath = await fs13.realpath(path17);
     logDebug(`[${scanContext}] Resolved repository path`, {
       resolvedRepoPath,
       originalPath: path17
@@ -15252,7 +15261,7 @@ var getLocalFiles = async ({
           absoluteFilePath
         );
         try {
-          const fileStat = await fs12.stat(absoluteFilePath);
+          const fileStat = await fs13.stat(absoluteFilePath);
           return {
             filename: nodePath.basename(absoluteFilePath),
             relativePath,
@@ -15287,7 +15296,7 @@ var getLocalFiles = async ({
 };
 
 // src/mcp/services/LocalMobbFolderService.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import path13 from "path";
 import { z as z33 } from "zod";
 init_GitService();
@@ -15379,15 +15388,15 @@ var LocalMobbFolderService = class {
         this.repoPath,
         this.defaultMobbFolderName
       );
-      if (!fs13.existsSync(mobbFolderPath)) {
+      if (!fs14.existsSync(mobbFolderPath)) {
         logInfo("[LocalMobbFolderService] Creating .mobb folder", {
           mobbFolderPath
         });
-        fs13.mkdirSync(mobbFolderPath, { recursive: true });
+        fs14.mkdirSync(mobbFolderPath, { recursive: true });
       } else {
         logDebug("[LocalMobbFolderService] .mobb folder already exists");
       }
-      const stats = fs13.statSync(mobbFolderPath);
+      const stats = fs14.statSync(mobbFolderPath);
       if (!stats.isDirectory()) {
         throw new Error(`Path exists but is not a directory: ${mobbFolderPath}`);
       }
@@ -15428,13 +15437,13 @@ var LocalMobbFolderService = class {
       logDebug("[LocalMobbFolderService] Git repository validated successfully");
     } else {
       try {
-        const stats = fs13.statSync(this.repoPath);
+        const stats = fs14.statSync(this.repoPath);
         if (!stats.isDirectory()) {
           throw new Error(
             `Path exists but is not a directory: ${this.repoPath}`
           );
         }
-        fs13.accessSync(this.repoPath, fs13.constants.R_OK | fs13.constants.W_OK);
+        fs14.accessSync(this.repoPath, fs14.constants.R_OK | fs14.constants.W_OK);
         logDebug(
           "[LocalMobbFolderService] Non-git directory validated successfully"
         );
@@ -15548,7 +15557,7 @@ var LocalMobbFolderService = class {
         baseFileName
       );
       const filePath = path13.join(mobbFolderPath, uniqueFileName);
-      await fs13.promises.writeFile(filePath, patch, "utf8");
+      await fs14.promises.writeFile(filePath, patch, "utf8");
       logInfo("[LocalMobbFolderService] Patch saved successfully", {
         filePath,
         fileName: uniqueFileName,
@@ -15609,7 +15618,7 @@ var LocalMobbFolderService = class {
     const extension = path13.parse(baseFileName).ext;
     let uniqueFileName = baseFileName;
     let index = 1;
-    while (fs13.existsSync(path13.join(folderPath, uniqueFileName))) {
+    while (fs14.existsSync(path13.join(folderPath, uniqueFileName))) {
       uniqueFileName = `${baseName}-${index}${extension}`;
       index++;
       if (index > 1e3) {
@@ -15643,15 +15652,15 @@ var LocalMobbFolderService = class {
       const patchInfoPath = path13.join(mobbFolderPath, "patchInfo.md");
       const markdownContent = this.generateFixMarkdown(fix, savedPatchFileName);
       let existingContent = "";
-      if (fs13.existsSync(patchInfoPath)) {
-        existingContent = await fs13.promises.readFile(patchInfoPath, "utf8");
+      if (fs14.existsSync(patchInfoPath)) {
+        existingContent = await fs14.promises.readFile(patchInfoPath, "utf8");
         logDebug("[LocalMobbFolderService] Existing patchInfo.md found");
       } else {
         logDebug("[LocalMobbFolderService] Creating new patchInfo.md file");
       }
       const separator = existingContent ? "\n\n================================================================================\n\n" : "";
       const updatedContent = `${markdownContent}${separator}${existingContent}`;
-      await fs13.promises.writeFile(patchInfoPath, updatedContent, "utf8");
+      await fs14.promises.writeFile(patchInfoPath, updatedContent, "utf8");
       logInfo("[LocalMobbFolderService] Patch info logged successfully", {
         patchInfoPath,
         fixId: fix.id,
@@ -16024,7 +16033,7 @@ import {
   unlinkSync,
   writeFileSync
 } from "fs";
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 import parseDiff2 from "parse-diff";
 import path14 from "path";
 var PatchApplicationService = class {
@@ -16522,7 +16531,7 @@ var PatchApplicationService = class {
       try {
         const absolutePath = path14.resolve(repositoryPath, targetFile);
         if (existsSync2(absolutePath)) {
-          const stats = await fs14.stat(absolutePath);
+          const stats = await fs15.stat(absolutePath);
           const fileModTime = stats.mtime.getTime();
           if (fileModTime > scanStartTime) {
             logError(
@@ -16563,7 +16572,7 @@ var PatchApplicationService = class {
     const appliedFixes = [];
     const failedFixes = [];
     const skippedFixes = [];
-    const resolvedRepoPath = await fs14.realpath(repositoryPath);
+    const resolvedRepoPath = await fs15.realpath(repositoryPath);
     logInfo(
       `[${scanContext}] Starting patch application for ${fixes.length} fixes`,
       {
@@ -16992,7 +17001,7 @@ init_configs();
 
 // src/mcp/services/FileOperations.ts
 init_FileUtils();
-import fs15 from "fs";
+import fs16 from "fs";
 import path15 from "path";
 import AdmZip2 from "adm-zip";
 var FileOperations = class {
@@ -17075,7 +17084,7 @@ var FileOperations = class {
         continue;
       }
       try {
-        await fs15.promises.access(absoluteFilepath, fs15.constants.R_OK);
+        await fs16.promises.access(absoluteFilepath, fs16.constants.R_OK);
         validatedPaths.push(filepath);
       } catch (error) {
         logDebug(
@@ -17094,7 +17103,7 @@ var FileOperations = class {
     const fileDataArray = [];
     for (const absolutePath of filePaths) {
       try {
-        const content = await fs15.promises.readFile(absolutePath);
+        const content = await fs16.promises.readFile(absolutePath);
         const relativePath = path15.basename(absolutePath);
         fileDataArray.push({
           relativePath,
@@ -17120,7 +17129,7 @@ var FileOperations = class {
     relativeFilepath
   }) {
     try {
-      return await fs15.promises.readFile(absoluteFilepath);
+      return await fs16.promises.readFile(absoluteFilepath);
     } catch (fsError) {
       logError(
         `[FileOperations] Failed to read ${relativeFilepath} from filesystem: ${fsError}`
@@ -18669,7 +18678,7 @@ var mcpHandler = async (_args) => {
 };
 
 // src/args/commands/review.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import chalk9 from "chalk";
 function reviewBuilder(yargs2) {
   return yargs2.option("f", {
@@ -18706,7 +18715,7 @@ function reviewBuilder(yargs2) {
   ).help();
 }
 function validateReviewOptions(argv) {
-  if (!fs16.existsSync(argv.f)) {
+  if (!fs17.existsSync(argv.f)) {
     throw new CliError(`
 Can't access ${chalk9.bold(argv.f)}`);
   }
@@ -18779,7 +18788,7 @@ async function addScmTokenHandler(args) {
 }
 
 // src/args/commands/upload_ai_blame.ts
-import fs17 from "fs/promises";
+import fs18 from "fs/promises";
 import path16 from "path";
 import chalk10 from "chalk";
 function uploadAiBlameBuilder(args) {
@@ -18829,7 +18838,7 @@ async function uploadAiBlameHandler(args) {
     const promptPath = String(prompts[i]);
     const inferencePath = String(inferences[i]);
     try {
-      await Promise.all([fs17.access(promptPath), fs17.access(inferencePath)]);
+      await Promise.all([fs18.access(promptPath), fs18.access(inferencePath)]);
     } catch {
       console.error(chalk10.red(`File not found for session ${i + 1}`));
       process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobbdev",
-  "version": "1.0.189",
+  "version": "1.0.190",
   "description": "Automated secure code remediation tool",
   "repository": "git+https://github.com/mobb-dev/bugsy.git",
   "main": "dist/index.mjs",