mobbdev 1.1.32 → 1.1.35

package/dist/args/commands/upload_ai_blame.mjs

@@ -4,6 +4,10 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/features/analysis/scm/env.ts
@@ -28,7 +32,7 @@ var init_env = __esm({
 });
 
 // src/mcp/core/configs.ts
-var MCP_LOGIN_MAX_WAIT, MCP_LOGIN_CHECK_DELAY, MCP_VUL_REPORT_DIGEST_TIMEOUT_MS, MCP_MAX_FILE_SIZE, MCP_PERIODIC_CHECK_INTERVAL, MCP_REPORT_ID_EXPIRATION_MS, MCP_TOOLS_BROWSER_COOLDOWN_MS, isAutoScan, MVS_AUTO_FIX_OVERRIDE, MCP_PERIODIC_TRACK_INTERVAL, MCP_SYSTEM_FIND_TIMEOUT_MS;
+var MCP_LOGIN_MAX_WAIT, MCP_LOGIN_CHECK_DELAY, MCP_VUL_REPORT_DIGEST_TIMEOUT_MS, MCP_MAX_FILE_SIZE, MCP_PERIODIC_CHECK_INTERVAL, MCP_DEFAULT_MAX_FILES_TO_SCAN, MCP_REPORT_ID_EXPIRATION_MS, MCP_TOOLS_BROWSER_COOLDOWN_MS, isAutoScan, MVS_AUTO_FIX_OVERRIDE, MCP_PERIODIC_TRACK_INTERVAL, MCP_SYSTEM_FIND_TIMEOUT_MS;
 var init_configs = __esm({
   "src/mcp/core/configs.ts"() {
     "use strict";
@@ -38,6 +42,7 @@ var init_configs = __esm({
     MCP_VUL_REPORT_DIGEST_TIMEOUT_MS = 30 * 60 * 1e3;
     MCP_MAX_FILE_SIZE = MAX_UPLOAD_FILE_SIZE_MB * 1024 * 1024;
     MCP_PERIODIC_CHECK_INTERVAL = 15 * 60 * 1e3;
+    MCP_DEFAULT_MAX_FILES_TO_SCAN = 10;
     MCP_REPORT_ID_EXPIRATION_MS = 2 * 60 * 60 * 1e3;
     MCP_TOOLS_BROWSER_COOLDOWN_MS = 24 * 60 * 60 * 1e3;
     isAutoScan = process.env["AUTO_SCAN"] !== "false";
@@ -48,16 +53,513 @@ var init_configs = __esm({
 });
 
 // src/features/analysis/scm/services/ExcludedDirs.ts
+var EXCLUDED_DIRS;
 var init_ExcludedDirs = __esm({
   "src/features/analysis/scm/services/ExcludedDirs.ts"() {
     "use strict";
+    EXCLUDED_DIRS = [
+      "$RECYCLE.BIN",
+      ".7z",
+      ".AppleDouble",
+      ".DS_Store",
+      ".Rproj.user",
+      ".Spotlight-V100",
+      ".Trashes",
+      ".adoc",
+      ".android",
+      ".angular",
+      ".atom",
+      ".aws-sam",
+      ".azure",
+      ".azure-pipelines",
+      ".babelrc",
+      ".babelrc.js",
+      ".bmp",
+      ".brackets.json",
+      ".browserslistrc",
+      ".build",
+      ".bundle",
+      ".bundle.js",
+      ".bzr",
+      ".c8rc",
+      ".c9",
+      ".cabal",
+      ".cabal-sandbox",
+      ".cache",
+      ".cache-loader",
+      ".cargo",
+      ".chunk.js",
+      ".circleci",
+      ".class",
+      ".classpath",
+      ".composer",
+      ".conf",
+      ".config",
+      ".cpanm",
+      ".crt",
+      ".cvs",
+      ".d.ts",
+      ".dart_tool",
+      ".db",
+      ".devcontainer",
+      ".dll",
+      ".docker",
+      ".dockerignore",
+      ".docusaurus",
+      ".dylib",
+      ".ebextensions",
+      ".eclipse",
+      ".editorconfig",
+      ".eggs",
+      ".ember-cli",
+      ".ensime_cache",
+      ".env",
+      ".env.vault",
+      ".eot",
+      ".eslintcache",
+      ".eslintrc",
+      ".eslintrc.js",
+      ".exe",
+      ".expo",
+      ".expo-shared",
+      ".flutter-plugins",
+      ".fseventsd",
+      ".gem",
+      ".gif",
+      ".git",
+      ".gitattributes",
+      ".github",
+      ".gitignore",
+      ".gitkeep",
+      ".gitlab",
+      ".gitlab-ci",
+      ".gitlab-ci.yml",
+      ".gitmodules",
+      ".gradle",
+      ".gvmrc",
+      ".gz",
+      ".hbuilder",
+      ".helm",
+      ".hg",
+      ".hgignore",
+      ".history",
+      ".htaccess",
+      ".husky",
+      ".ico",
+      ".idea",
+      ".ini",
+      ".ionic",
+      ".ipynb_checkpoints",
+      ".ivy2",
+      ".jekyll-cache",
+      ".jest-cache",
+      ".jpeg",
+      ".jpg",
+      ".jscsrc",
+      ".jshintrc",
+      ".json",
+      ".k8s",
+      ".keep",
+      ".key",
+      ".kubernetes",
+      ".lcov",
+      ".lock",
+      ".log",
+      ".logs",
+      ".m2",
+      ".mailmap",
+      ".md",
+      ".metadata",
+      ".metals",
+      ".min.css",
+      ".min.html",
+      ".min.js",
+      ".mvn",
+      ".mypy_cache",
+      ".nbproject",
+      ".netbeans",
+      ".netlify",
+      ".next",
+      ".node-version",
+      ".node_modules",
+      ".npmrc",
+      ".nuget",
+      ".nunit",
+      ".nuxt",
+      ".nvm",
+      ".nvmrc",
+      ".nx",
+      ".nyc_output",
+      ".nycrc",
+      ".o",
+      ".obj",
+      ".otf",
+      ".output",
+      ".p12",
+      ".parcel-cache",
+      ".pem",
+      ".pfx",
+      ".phpunit.result.cache",
+      ".png",
+      ".pnp",
+      ".pnp.cjs",
+      ".pnp.js",
+      ".pnpm",
+      ".pnpm-state",
+      ".pnpm-store",
+      ".pnpmfile.cjs",
+      ".prettierrc",
+      ".prettierrc.js",
+      ".project",
+      ".project.vim",
+      ".pub-cache",
+      ".pulumi",
+      ".pyc",
+      ".pyenv",
+      ".pyo",
+      ".pytest_cache",
+      ".python-version",
+      ".pythonrc",
+      ".quasar",
+      ".rar",
+      ".rbenv-version",
+      ".react-native",
+      ".rebar3",
+      ".rollup.cache",
+      ".rst",
+      ".ruby-version",
+      ".ruff_cache",
+      ".rush",
+      ".rvm",
+      ".rvmrc",
+      ".sass-cache",
+      ".sbt",
+      ".serverless",
+      ".settings",
+      ".snap",
+      ".so",
+      ".spec.js",
+      ".spec.jsx",
+      ".spec.ts",
+      ".spec.tsx",
+      ".sql",
+      ".sqlite",
+      ".stack-work",
+      ".storybook",
+      ".stylelintcache",
+      ".stylelintrc",
+      ".stylelintrc.js",
+      ".sublime-project",
+      ".sublime-workspace",
+      ".svelte-kit",
+      ".svg",
+      ".svn",
+      ".swcrc",
+      ".tar",
+      ".temp",
+      ".terraform",
+      ".test.js",
+      ".test.jsx",
+      ".test.ts",
+      ".test.tsx",
+      ".tiff",
+      ".tmp",
+      ".toml",
+      ".tox",
+      ".travis",
+      ".travis.yml",
+      ".ttf",
+      ".turbo",
+      ".txt",
+      ".vagrant",
+      ".venv",
+      ".vite",
+      ".vs",
+      ".vscode",
+      ".webp",
+      ".webpack",
+      ".woff",
+      ".woff2",
+      ".wrangler",
+      ".xml",
+      ".yaml",
+      ".yarn",
+      ".yarnrc",
+      ".yml",
+      ".zip",
+      "Carthage",
+      "Debug",
+      "DerivedData",
+      "Godeps",
+      "Release",
+      "TestResults",
+      "__pycache__",
+      "_build",
+      "allure-results",
+      "bazel",
+      "benchmark",
+      "benchmarks",
+      "bin",
+      "bower_components",
+      "buck-out",
+      "build",
+      "build-cache",
+      "build_tools",
+      "builds",
+      "cache",
+      "changelog",
+      "changelogs",
+      "compiled",
+      "copyright",
+      "coverage",
+      "debug",
+      "deploy",
+      "deployment",
+      "dist",
+      "dist-newstyle",
+      "dist-packages",
+      "docker",
+      "dockerfile",
+      "egg-info",
+      "elm-stuff",
+      "fonts",
+      "gemfile",
+      "generated",
+      "go.mod",
+      "go.sum",
+      "jars",
+      "jenkinsfile",
+      "jspm_packages",
+      "junit-reports",
+      "makefile",
+      "mock_data",
+      "nbproject",
+      "node_modules",
+      "notice",
+      "obj",
+      "out",
+      "out-tsc",
+      "output",
+      "packrat",
+      "pipfile",
+      "pycache",
+      "readme",
+      "sdist",
+      "snapshots",
+      "target",
+      "debug",
+      "temp",
+      "tempfiles",
+      "test-reports",
+      "test-results",
+      "test_output",
+      "third-party",
+      "third_party",
+      "thirdparty",
+      "tmp",
+      "vendor",
+      "bundle",
+      "venv",
+      "virtualenv",
+      "webpack-cache",
+      "www",
+      "wwwroot",
+      "xunit"
+    ];
   }
 });
 
 // src/features/analysis/scm/services/FilePatterns.ts
+var EXCLUDED_FILE_PATTERNS, SUPPORTED_EXTENSIONS, IMPORTANT_PROJECT_FILES;
 var init_FilePatterns = __esm({
   "src/features/analysis/scm/services/FilePatterns.ts"() {
     "use strict";
+    EXCLUDED_FILE_PATTERNS = [
+      // Minified and bundled files (have supported extensions but should be excluded)
+      ".min.js",
+      ".min.html",
+      ".bundle.js",
+      ".chunk.js",
+      // Test files (have supported extensions but should be excluded)
+      ".test.js",
+      ".test.ts",
+      ".test.jsx",
+      ".test.tsx",
+      ".spec.js",
+      ".spec.ts",
+      ".spec.jsx",
+      ".spec.tsx",
+      // TypeScript declaration files
+      ".d.ts",
+      // Runtime version files that have supported extensions
+      ".pnpmfile.cjs",
+      // Language-specific files with supported extensions that should be excluded
+      "go.sum",
+      "project.clj",
+      "setup.py",
+      "setup.cfg",
+      "manifest.in",
+      // Build tool configuration files (have supported extensions but should be excluded)
+      "gulpfile.js",
+      "gruntfile.js",
+      "webpack.config.js",
+      "webpack.config.ts",
+      "rollup.config.js",
+      "vite.config.js",
+      "vite.config.ts",
+      "next.config.js",
+      "nuxt.config.js",
+      "tailwind.config.js",
+      "postcss.config.js",
+      // Linter and formatter config files (with supported extensions)
+      ".babelrc.js",
+      ".eslintrc.js",
+      ".prettierrc.js",
+      ".stylelintrc.js",
+      // Test framework config files (with supported extensions)
+      "jest.config.js",
+      "jest.config.ts",
+      "vitest.config.js",
+      "karma.conf.js",
+      "protractor.conf.js",
+      "cypress.config.js",
+      "playwright.config.js"
+    ];
+    SUPPORTED_EXTENSIONS = [
+      // Apex
+      ".cls",
+      // Bash
+      ".bash",
+      ".sh",
+      // C
+      ".c",
+      ".h",
+      // Cairo
+      ".cairo",
+      // Circom
+      ".circom",
+      // Clojure
+      ".clj",
+      ".cljs",
+      ".cljc",
+      ".edn",
+      // C++
+      ".cc",
+      ".cpp",
+      ".cxx",
+      ".c++",
+      ".pcc",
+      ".tpp",
+      ".C",
+      ".hh",
+      ".hpp",
+      ".hxx",
+      ".inl",
+      ".ipp",
+      // C#
+      ".cs",
+      // Dart
+      ".dart",
+      // Dockerfile
+      ".dockerfile",
+      ".Dockerfile",
+      "Dockerfile",
+      "dockerfile",
+      // Elixir
+      ".ex",
+      ".exs",
+      // Go
+      ".go",
+      // Hack
+      ".hack",
+      ".hck",
+      ".hh",
+      // HTML
+      ".htm",
+      ".html",
+      // Java
+      ".java",
+      // JavaScript
+      ".cjs",
+      ".js",
+      ".jsx",
+      ".mjs",
+      // JSON
+      ".json",
+      ".ipynb",
+      // Jsonnet
+      ".jsonnet",
+      ".libsonnet",
+      // Julia
+      ".jl",
+      // Kotlin
+      ".kt",
+      ".kts",
+      ".ktm",
+      // Lisp
+      ".lisp",
+      ".cl",
+      ".el",
+      // Lua
+      ".lua",
+      // Move (both Sui and Aptos)
+      ".move",
+      // OCaml
+      ".ml",
+      ".mli",
+      // PHP
+      ".php",
+      ".tpl",
+      ".phtml",
+      // PromQL
+      ".promql",
+      // Protocol Buffers
+      ".proto",
+      // Python
+      ".py",
+      ".pyi",
+      // QL
+      ".ql",
+      ".qll",
+      // R
+      ".r",
+      ".R",
+      // Ruby
+      ".rb",
+      // Rust
+      ".rs",
+      // Scala
+      ".scala",
+      // Scheme
+      ".scm",
+      ".ss",
+      // Solidity
+      ".sol",
+      // Swift
+      ".swift",
+      // Terraform
+      ".tf",
+      ".hcl",
+      ".tfvars",
+      // TypeScript
+      ".ts",
+      ".tsx",
+      // Vue
+      ".vue",
+      // XML
+      ".xml",
+      ".plist",
+      // YAML
+      ".yml",
+      ".yaml"
+    ];
+    IMPORTANT_PROJECT_FILES = [
+      "package.json",
+      "package-lock.json",
+      "pnpm-lock.yaml",
+      "yarn.lock",
+      "pom.xml"
+    ];
   }
 });
 
@@ -66,27 +568,795 @@ import fs4 from "fs";
 import { promises as fsPromises } from "fs";
 import { isBinary } from "istextorbinary";
 import path4 from "path";
+var FileUtils;
 var init_FileUtils = __esm({
   "src/features/analysis/scm/services/FileUtils.ts"() {
     "use strict";
     init_configs();
     init_ExcludedDirs();
     init_FilePatterns();
+    FileUtils = class {
+      // Important project configuration files that should always be included
+      static isExcludedFileType(filepath) {
+        const basename2 = path4.basename(filepath).toLowerCase();
+        if (IMPORTANT_PROJECT_FILES.includes(basename2)) {
+          return false;
+        }
+        const ext = path4.extname(filepath).toLowerCase();
+        const isSupported = SUPPORTED_EXTENSIONS.includes(ext) || SUPPORTED_EXTENSIONS.includes(basename2);
+        if (!isSupported) {
+          return true;
+        }
+        if (EXCLUDED_FILE_PATTERNS.some((pattern) => basename2.endsWith(pattern))) {
+          return true;
+        }
+        return false;
+      }
+      static shouldPackFile(filepath, maxFileSize = MCP_MAX_FILE_SIZE) {
+        const absoluteFilepath = path4.resolve(filepath);
+        if (this.isExcludedFileType(filepath)) {
+          return false;
+        }
+        try {
+          const stats = fs4.statSync(absoluteFilepath);
+          if (stats.size > maxFileSize) {
+            return false;
+          }
+          const data = fs4.readFileSync(absoluteFilepath);
+          if (isBinary(null, data)) {
+            return false;
+          }
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      // Process directory at repository root level with special handling for excluded root directories
+      static async processRootDirectory(dir, excludedRootDirectories) {
+        const visitedDirs = /* @__PURE__ */ new Set();
+        return this.processDirectory(
+          dir,
+          dir,
+          excludedRootDirectories,
+          0,
+          visitedDirs,
+          true
+        );
+      }
+      // Process directories with tracking to prevent circular symlink recursion
+      static async processDirectory(dir, rootDir, excludedRootDirectories = [], depth = 0, visitedDirs = /* @__PURE__ */ new Set(), isRootLevel = false) {
+        if (depth > 20) {
+          return [];
+        }
+        let canonicalPath;
+        try {
+          canonicalPath = await fsPromises.realpath(dir);
+          if (visitedDirs.has(canonicalPath)) {
+            return [];
+          }
+          visitedDirs.add(canonicalPath);
+        } catch {
+          return [];
+        }
+        try {
+          await fsPromises.access(dir, fs4.constants.R_OK);
+        } catch {
+          return [];
+        }
+        const items = await fsPromises.readdir(dir);
+        const results = [];
+        const filePromises = [];
+        for (const item of items) {
+          const fullPath = path4.join(dir, item);
+          try {
+            await fsPromises.access(fullPath, fs4.constants.R_OK);
+            const stat = await fsPromises.stat(fullPath);
+            if (stat.isDirectory()) {
+              if (isRootLevel && excludedRootDirectories.includes(item)) {
+                continue;
+              }
+              filePromises.push(
+                this.processDirectory(fullPath, rootDir, [], depth + 1, visitedDirs)
+              );
+            } else {
+              results.push({
+                name: item,
+                fullPath,
+                relativePath: path4.relative(rootDir, fullPath),
+                time: stat.mtime.getTime(),
+                isFile: true
+              });
+            }
+          } catch {
+            continue;
+          }
+        }
+        const subdirResults = await Promise.all(filePromises);
+        for (const subdirResult of subdirResults) {
+          results.push(...subdirResult);
+        }
+        return results;
+      }
+      static async getLastChangedFiles({
+        dir,
+        maxFileSize,
+        maxFiles = MCP_DEFAULT_MAX_FILES_TO_SCAN,
+        isAllFilesScan
+      }) {
+        try {
+          const stats = fs4.statSync(dir);
+          if (!stats.isDirectory()) return [];
+        } catch {
+          return [];
+        }
+        let gitMatcher = null;
+        try {
+          const { GitService: GitService2 } = await Promise.resolve().then(() => (init_GitService(), GitService_exports));
+          const gitService = new GitService2(dir);
+          gitMatcher = await gitService.getGitignoreMatcher();
+        } catch (e) {
+        }
+        const allFiles = await this.processRootDirectory(dir, EXCLUDED_DIRS);
+        const filteredFiles = allFiles.filter(
+          (file) => this.shouldPackFile(file.fullPath, maxFileSize) && !gitMatcher?.ignores(file.relativePath)
+        ).sort((a, b) => b.time - a.time).map((file) => file.relativePath);
+        if (isAllFilesScan) {
+          return filteredFiles;
+        } else {
+          return filteredFiles.slice(0, maxFiles);
+        }
+      }
+    };
   }
 });
 
 // src/features/analysis/scm/services/GitService.ts
+var GitService_exports = {};
+__export(GitService_exports, {
+  GitService: () => GitService,
+  isGitHubUrl: () => isGitHubUrl,
+  normalizeGitUrl: () => normalizeGitUrl
+});
 import fs5 from "fs";
 import ignore from "ignore";
 import * as path5 from "path";
 import { simpleGit as simpleGit2 } from "simple-git";
-var MAX_COMMIT_DIFF_SIZE_BYTES;
+function normalizeGitUrl(url) {
+  let normalizedUrl = url;
+  if (normalizedUrl.endsWith(".git")) {
+    normalizedUrl = normalizedUrl.slice(0, -".git".length);
+  }
+  const sshToHttpsMappings = [
+    // GitHub
+    { pattern: "git@github.com:", replacement: "https://github.com/" },
+    // GitLab
+    { pattern: "git@gitlab.com:", replacement: "https://gitlab.com/" },
+    // Bitbucket
+    { pattern: "git@bitbucket.org:", replacement: "https://bitbucket.org/" },
+    // Azure DevOps (SSH format)
+    {
+      pattern: "git@ssh.dev.azure.com:",
+      replacement: "https://dev.azure.com/"
+    },
+    // Azure DevOps (alternative SSH format)
+    {
+      pattern: /git@([^:]+):v3\/([^/]+)\/([^/]+)\/([^/]+)/,
+      replacement: "https://$1/$2/_git/$4"
+    }
+  ];
+  for (const mapping of sshToHttpsMappings) {
+    if (typeof mapping.pattern === "string") {
+      if (normalizedUrl.startsWith(mapping.pattern)) {
+        normalizedUrl = normalizedUrl.replace(
+          mapping.pattern,
+          mapping.replacement
+        );
+        break;
+      }
+    } else {
+      const match = normalizedUrl.match(mapping.pattern);
+      if (match) {
+        normalizedUrl = normalizedUrl.replace(
+          mapping.pattern,
+          mapping.replacement
+        );
+        break;
+      }
+    }
+  }
+  if (normalizedUrl.startsWith("https://") || normalizedUrl.startsWith("http://")) {
+    normalizedUrl = normalizedUrl.replace(/^(https?:\/\/)([^@/]+@)/, "$1");
+  }
+  return normalizedUrl;
+}
+function isGitHubUrl(normalizedUrl) {
+  try {
+    const url = new URL(normalizedUrl);
+    const host = url.host.toLowerCase();
+    return host === "github.com" || host.endsWith(".github.com");
+  } catch {
+    return false;
+  }
+}
+var MAX_COMMIT_DIFF_SIZE_BYTES, GitService;
 var init_GitService = __esm({
   "src/features/analysis/scm/services/GitService.ts"() {
     "use strict";
     init_configs();
     init_FileUtils();
     MAX_COMMIT_DIFF_SIZE_BYTES = 3 * 1024 * 1024;
+    GitService = class {
+      constructor(repositoryPath, log) {
+        __publicField(this, "git");
+        __publicField(this, "repositoryPath");
+        __publicField(this, "log");
+        const noopLog = (_message, _level, _data) => {
+        };
+        this.log = log || noopLog;
+        this.git = simpleGit2(repositoryPath, { binary: "git" });
+        this.repositoryPath = repositoryPath;
+        this.log("[GitService] Git service initialized", "debug", {
+          repositoryPath
+        });
+      }
+      /**
+       * Checks if the current path is within a git repository
+       * @returns Promise<boolean> True if it's a git repository, false otherwise
+       */
+      async isGitRepository() {
+        try {
+          const isRepo = await this.git.checkIsRepo();
+          if (!isRepo) {
+            this.log("[GitService] Not a git repository", "debug");
+            return false;
+          }
+          await this.git.revparse(["--show-toplevel"]);
+          return true;
+        } catch (error) {
+          this.log("[GitService] Not a git repository", "debug", {
+            error: String(error)
+          });
+          return false;
+        }
+      }
+      /**
+       * Validates that the path is a valid git repository
+       */
+      async validateRepository() {
+        this.log("[GitService] Validating git repository", "debug");
+        try {
+          const isRepo = await this.git.checkIsRepo();
+          if (!isRepo) {
+            const error = "[GitService] Path is not a valid git repository";
+            this.log(error, "error");
+            return { isValid: false, error };
+          }
+          this.log("[GitService] Git repository validation successful", "debug");
+          return { isValid: true };
+        } catch (error) {
+          const errorMessage = `Failed to verify git repository: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error });
+          return { isValid: false, error: errorMessage };
+        }
+      }
+      /**
+       * Gets the current git status and returns changed files
+       */
+      async getChangedFiles() {
+        this.log("[GitService] Getting git status", "debug");
+        try {
+          const status = await this.git.status();
+          const gitRoot = await this.git.revparse(["--show-toplevel"]);
+          const relativePathFromGitRoot = path5.relative(
+            gitRoot,
+            this.repositoryPath
+          );
+          const deletedFiles = status.files.filter((file) => file.index === "D" || file.working_dir === "D").map((file) => file.path);
+          const files = status.files.filter((file) => {
+            return !(file.index === "D" || file.working_dir === "D");
+          }).map((file) => {
+            const gitRelativePath = file.path;
+            if (relativePathFromGitRoot === "") {
+              return gitRelativePath;
+            }
+            if (gitRelativePath.startsWith(relativePathFromGitRoot + "/")) {
+              return gitRelativePath.substring(relativePathFromGitRoot.length + 1);
+            }
+            const safeInput = path5.basename(
+              String(gitRelativePath || "").replace("\0", "").replace(/^(\.\.(\/|\\$))+/, "")
+            );
+            return path5.relative(
+              this.repositoryPath,
+              path5.join(gitRoot, safeInput)
+            );
+          });
+          this.log("[GitService] Git status retrieved", "info", {
+            fileCount: files.length,
+            files: files.slice(0, 10),
+            // Log first 10 files to avoid spam
+            deletedFileCount: deletedFiles.length,
+            deletedFiles: deletedFiles.slice(0, 10),
+            gitRoot,
+            workingDir: this.repositoryPath,
+            relativePathFromGitRoot
+          });
+          return { files, deletedFiles, status };
+        } catch (error) {
+          const errorMessage = `Failed to get git status: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error });
+          throw new Error(errorMessage);
+        }
+      }
+      /**
+       * Gets git repository information including remote URL, current commit hash, and branch name
+       */
+      async getGitInfo() {
+        this.log("[GitService] Getting git repository information", "debug");
+        try {
+          const [repoUrl, hash, reference] = await Promise.all([
+            this.git.getConfig("remote.origin.url"),
+            this.git.revparse(["HEAD"]),
+            this.git.revparse(["--abbrev-ref", "HEAD"])
+          ]);
+          const normalizedRepoUrl = repoUrl.value ? normalizeGitUrl(repoUrl.value) : "";
+          this.log("[GitService] Git repository information retrieved", "debug", {
+            repoUrl: normalizedRepoUrl,
+            hash,
+            reference
+          });
+          return {
+            repoUrl: normalizedRepoUrl,
+            hash,
+            reference
+          };
+        } catch (error) {
+          const errorMessage = `Failed to get git repository information: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error });
+          throw new Error(errorMessage);
+        }
+      }
+      /**
+       * Validates if a branch name is valid according to git's rules
+       */
+      async isValidBranchName(branchName) {
+        this.log("[GitService] Validating branch name", "debug", { branchName });
+        try {
+          const result = await this.git.raw([
+            "check-ref-format",
+            "--branch",
+            branchName
+          ]);
+          const isValid = Boolean(result);
+          this.log("[GitService] Branch name validation result", "debug", {
+            branchName,
+            isValid
+          });
+          return isValid;
+        } catch (error) {
+          this.log("[GitService] Branch name validation failed", "debug", {
+            branchName,
+            error
+          });
+          return false;
+        }
+      }
+      /**
+       * Gets the current branch name
+       */
+      async getCurrentBranch() {
+        this.log("[GitService] Getting current branch name", "debug");
+        try {
+          const branch = await this.git.revparse(["--abbrev-ref", "HEAD"]);
+          this.log("[GitService] Current branch retrieved", "debug", { branch });
+          return branch;
+        } catch (error) {
+          const errorMessage = `Failed to get current branch: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error });
+          throw new Error(errorMessage);
+        }
+      }
+      /**
+       * Gets the current commit hash
+       */
+      async getCurrentCommitHash() {
+        this.log("[GitService] Getting current commit hash", "debug");
+        try {
+          const hash = await this.git.revparse(["HEAD"]);
+          this.log("[GitService] Current commit hash retrieved", "debug", { hash });
+          return hash;
+        } catch (error) {
+          const errorMessage = `Failed to get current commit hash: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error });
+          throw new Error(errorMessage);
+        }
+      }
+      /**
+       * Gets both the current commit hash and current branch name
+       */
+      async getCurrentCommitAndBranch() {
+        this.log("[GitService] Getting current commit hash and branch", "debug");
+        try {
+          const [hash, branch] = await Promise.all([
+            this.git.revparse(["HEAD"]),
+            this.git.revparse(["--abbrev-ref", "HEAD"])
+          ]);
+          this.log(
+            "[GitService] Current commit hash and branch retrieved",
+            "debug",
+            {
+              hash,
+              branch
+            }
+          );
+          return { hash, branch };
+        } catch (error) {
+          const errorMessage = `Failed to get current commit hash and branch: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error });
+          return { hash: "", branch: "" };
+        }
+      }
+      /**
+       * Gets the remote repository URL (origin)
+       */
+      async getRemoteUrl() {
+        this.log("[GitService] Getting remote repository URL", "debug");
+        try {
+          const remoteUrl = await this.git.getConfig("remote.origin.url");
+          const url = remoteUrl.value || "";
+          const normalizedUrl = normalizeGitUrl(url);
+          this.log("[GitService] Remote repository URL retrieved", "debug", {
+            url: normalizedUrl
+          });
+          return normalizedUrl;
+        } catch (error) {
+          const errorMessage = `Failed to get remote repository URL: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error });
+          throw new Error(errorMessage);
+        }
+      }
+      /**
+       * Gets the maxFiles most recently changed files, starting with current changes and then from commit history
+       */
+      async getRecentlyChangedFiles({
+        maxFiles = MCP_DEFAULT_MAX_FILES_TO_SCAN
+      }) {
+        this.log(
+          `[GitService] Getting the ${maxFiles} most recently changed files, starting with current changes`,
+          "debug"
+        );
+        try {
+          const currentChanges = await this.getChangedFiles();
+          const gitRoot = await this.git.revparse(["--show-toplevel"]);
+          const relativePathFromGitRoot = path5.relative(
+            gitRoot,
+            this.repositoryPath
+          );
+          const fileSet = /* @__PURE__ */ new Set();
+          let commitsProcessed = 0;
+          const consideredFiles = [];
+          for (const file of currentChanges.files) {
+            if (fileSet.size >= maxFiles) {
+              break;
+            }
+            const fullPath = path5.join(this.repositoryPath, file);
+            if (await FileUtils.shouldPackFile(fullPath) && !file.startsWith("..")) {
+              fileSet.add(file);
+            }
+          }
+          this.log(
+            `[GitService] Added ${fileSet.size} files from current changes`,
+            "debug",
+            {
+              filesFromCurrentChanges: fileSet.size,
+              currentChangesTotal: currentChanges.files.length
+            }
+          );
+          const logResult = await this.git.log({
+            maxCount: maxFiles * 5,
+            // 5 times the max files to scan to ensure we find enough files
+            format: {
+              hash: "%H",
+              date: "%ai",
+              message: "%s",
+              //the field name author_name can't follow the naming convention as we are using the git log command
+              author_name: "%an"
+            }
+          });
+          for (const commit of logResult.all) {
+            if (fileSet.size >= maxFiles) {
+              break;
+            }
+            commitsProcessed++;
+            try {
+              const filesOutput = await this.git.show([
+                "--name-only",
+                "--pretty=format:",
+                commit.hash
+              ]);
+              const commitFiles = filesOutput.split("\n").filter((file) => file.trim() !== "");
+              for (const file of commitFiles) {
+                if (fileSet.size >= maxFiles) {
+                  break;
+                }
+                const gitRelativePath = file.trim();
+                let adjustedPath;
+                if (relativePathFromGitRoot === "") {
+                  adjustedPath = gitRelativePath;
+                } else if (gitRelativePath.startsWith(relativePathFromGitRoot + "/")) {
+                  adjustedPath = gitRelativePath.substring(
+                    relativePathFromGitRoot.length + 1
+                  );
+                } else {
+                  adjustedPath = path5.relative(
+                    this.repositoryPath,
+                    path5.join(gitRoot, gitRelativePath)
+                  );
+                }
+                consideredFiles.push(adjustedPath);
+                if (!fileSet.has(adjustedPath) && await FileUtils.shouldPackFile(
+                  path5.join(gitRoot, gitRelativePath)
+                ) && !adjustedPath.startsWith("..")) {
+                  fileSet.add(adjustedPath);
+                }
+              }
+            } catch (showError) {
+              this.log(
+                `[GitService] Could not get files for commit ${commit.hash}`,
+                "debug",
+                {
+                  error: showError
+                }
+              );
+            }
+          }
+          const files = Array.from(fileSet);
+          if (consideredFiles.length > 0) {
+            this.log(
+              `[GitService] Considered ${consideredFiles.length} files during recent file search`,
+              "debug",
+              { consideredFiles }
+            );
+          }
+          this.log("[GitService] Recently changed files retrieved", "info", {
+            fileCount: files.length,
+            commitsProcessed,
+            totalCommitsAvailable: logResult.all.length,
+            files: files.slice(0, maxFiles),
+            // Log the files (should be all of them since we limit to maxFiles)
+            gitRoot,
+            workingDir: this.repositoryPath,
+            relativePathFromGitRoot
+          });
+          return {
+            files,
+            commitCount: commitsProcessed
+          };
+        } catch (error) {
+          const errorMessage = `Failed to get recently changed files: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error });
+          throw new Error(errorMessage);
+        }
+      }
+      /**
+       * Fetches the contents of the .gitignore file from the repository
+       * @returns The contents of the .gitignore file as a string, or null if the file doesn't exist
+       */
+      async getGitignoreContent() {
+        this.log("[GitService] Getting .gitignore contents", "debug");
+        try {
+          let combinedContent = "";
+          const localGitignorePath = path5.join(this.repositoryPath, ".gitignore");
+          if (fs5.existsSync(localGitignorePath)) {
+            const localContent = fs5.readFileSync(localGitignorePath, "utf8");
+            combinedContent += `${localContent}
+`;
+          }
+          try {
+            const gitRoot = await this.git.revparse(["--show-toplevel"]);
+            const rootGitignorePath = path5.join(gitRoot, ".gitignore");
+            if (fs5.existsSync(rootGitignorePath)) {
+              const rootContent = fs5.readFileSync(rootGitignorePath, "utf8");
+              if (rootContent.trim() !== combinedContent.trim()) {
+                combinedContent += `
+${rootContent}`;
+              }
+            }
+          } catch (rootErr) {
+            this.log(
+              "[GitService] Unable to resolve git root while reading .gitignore",
+              "debug",
+              { error: rootErr }
+            );
+          }
+          if (combinedContent.trim() === "") {
+            this.log("[GitService] .gitignore file not found", "debug");
+            return null;
+          }
+          this.log(
+            "[GitService] .gitignore contents retrieved successfully",
+            "debug"
+          );
+          return combinedContent.trimEnd();
+        } catch (error) {
+          const errorMessage = `Failed to get .gitignore contents: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error });
+          return null;
+        }
+      }
+      async getGitignoreMatcher() {
+        const content = await this.getGitignoreContent();
+        if (!content) return null;
+        return ignore().add(content);
+      }
+      /**
+       * Gets the git repository root directory path
+       * @returns Absolute path to the git repository root
+       */
+      async getGitRoot() {
+        this.log("[GitService] Getting git repository root", "debug");
+        try {
+          const gitRoot = await this.git.revparse(["--show-toplevel"]);
+          this.log("[GitService] Git root retrieved", "debug", { gitRoot });
+          return gitRoot;
+        } catch (error) {
+          const errorMessage = `Failed to get git repository root: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error });
+          throw new Error(errorMessage);
+        }
+      }
+      /**
+       * Ensures that a specific entry exists in the .gitignore file
+       * Creates .gitignore if it doesn't exist, adds the entry if not present
+       * @param entry The entry to add to .gitignore (e.g., '.mobb', 'node_modules')
+       * @returns True if entry was added, false if it already existed
+       */
+      async ensureGitignoreEntry(entry) {
+        this.log("[GitService] Ensuring .gitignore entry", "debug", { entry });
+        try {
+          const gitRoot = await this.getGitRoot();
+          const gitignorePath = path5.join(gitRoot, ".gitignore");
+          let gitignoreContent = "";
+          if (fs5.existsSync(gitignorePath)) {
+            gitignoreContent = fs5.readFileSync(gitignorePath, "utf8");
+            this.log("[GitService] .gitignore file exists", "debug");
+          } else {
+            this.log("[GitService] Creating .gitignore file", "info", {
+              gitignorePath
+            });
+          }
+          if (gitignoreContent.includes(entry)) {
+            this.log("[GitService] Entry already exists in .gitignore", "debug", {
+              entry
+            });
+            return false;
+          }
+          this.log("[GitService] Adding entry to .gitignore", "info", { entry });
+          const newLine = gitignoreContent.endsWith("\n") || gitignoreContent === "" ? "" : "\n";
+          const updatedContent = `${gitignoreContent}${newLine}${entry}
+`;
+          fs5.writeFileSync(gitignorePath, updatedContent, "utf8");
+          this.log("[GitService] .gitignore updated successfully", "debug", {
+            entry
+          });
+          return true;
+        } catch (error) {
+          const errorMessage = `Failed to ensure .gitignore entry: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error, entry });
+          throw new Error(errorMessage);
+        }
+      }
+      /**
+       * Checks if the .gitignore file exists in the repository root
+       * @returns True if .gitignore exists, false otherwise
+       */
+      async gitignoreExists() {
+        this.log("[GitService] Checking if .gitignore exists", "debug");
+        try {
+          const gitRoot = await this.getGitRoot();
+          const gitignorePath = path5.join(gitRoot, ".gitignore");
+          const exists = fs5.existsSync(gitignorePath);
+          this.log("[GitService] .gitignore existence check complete", "debug", {
+            exists
+          });
+          return exists;
+        } catch (error) {
+          const errorMessage = `Failed to check .gitignore existence: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "error", { error });
+          throw new Error(errorMessage);
+        }
+      }
+      /**
+       * Gets timestamps for parent commits in a single git call.
+       * @param parentShas Array of parent commit SHAs
+       * @returns Array of parent commits with timestamps, or undefined if unavailable
+       */
+      async getParentCommitTimestamps(parentShas) {
+        if (parentShas.length === 0) {
+          return void 0;
+        }
+        try {
+          const output = await this.git.raw([
+            "log",
+            "--format=%H %cI",
+            "--no-walk",
+            ...parentShas
+          ]);
+          const parentCommits = output.trim().split("\n").filter(Boolean).map((line) => {
+            const [sha, ts] = line.split(" ");
+            return { sha: sha ?? "", timestamp: new Date(ts ?? "") };
+          }).filter((p) => p.sha !== "");
+          return parentCommits.length > 0 ? parentCommits : void 0;
+        } catch {
+          this.log("[GitService] Could not get parent commit timestamps", "debug", {
+            parentShas
+          });
+          return void 0;
+        }
+      }
+      /**
+       * Gets local commit data including diff, timestamp, and parent commits.
+       * Used by Tracy extension to send commit data directly without requiring SCM token.
+       * @param commitSha The commit SHA to get data for
+       * @param maxDiffSizeBytes Maximum diff size in bytes (default 3MB). Returns null if exceeded.
+       * @returns Commit data or null if unavailable/too large
+       */
+      async getLocalCommitData(commitSha, maxDiffSizeBytes = MAX_COMMIT_DIFF_SIZE_BYTES) {
+        this.log("[GitService] Getting local commit data", "debug", { commitSha });
+        try {
+          const DIFF_DELIMITER = "---MOBB_DIFF_START---";
+          const output = await this.git.show([
+            commitSha,
+            `--format=%cI%n%P%n${DIFF_DELIMITER}`,
+            "--patch"
+          ]);
+          const delimiterIndex = output.indexOf(DIFF_DELIMITER);
+          if (delimiterIndex === -1) {
+            this.log("[GitService] Could not parse git show output", "warning", {
+              commitSha
+            });
+            return null;
+          }
+          const metadataOutput = output.substring(0, delimiterIndex);
+          const diff = output.substring(delimiterIndex + DIFF_DELIMITER.length + 1);
+          const diffSizeBytes = Buffer.byteLength(diff, "utf8");
+          if (diffSizeBytes > maxDiffSizeBytes) {
+            this.log("[GitService] Commit diff exceeds size limit", "warning", {
+              commitSha,
+              diffSizeBytes,
+              maxDiffSizeBytes
+            });
+            return null;
+          }
+          const metadataLines = metadataOutput.trim().split("\n");
+          if (metadataLines.length < 1 || !metadataLines[0]) {
+            this.log("[GitService] Unexpected metadata format", "warning", {
+              commitSha,
+              metadataLines
+            });
+            return null;
+          }
+          const timestampStr = metadataLines[0];
+          const timestamp = new Date(timestampStr);
+          const parentShas = (metadataLines[1] ?? "").trim().split(/\s+/).filter(Boolean);
+          const parentCommits = await this.getParentCommitTimestamps(parentShas);
+          this.log("[GitService] Local commit data retrieved", "debug", {
+            commitSha,
+            diffSizeBytes,
+            timestamp: timestamp.toISOString(),
+            parentCommitCount: parentCommits?.length ?? 0
+          });
+          return {
+            diff,
+            timestamp,
+            parentCommits
+          };
+        } catch (error) {
+          const errorMessage = `Failed to get local commit data: ${error.message}`;
+          this.log(`[GitService] ${errorMessage}`, "debug", { error, commitSha });
+          return null;
+        }
+      }
+    };
   }
 });
 
@@ -895,9 +2165,10 @@ var GetPromptSummaryDocument = `
         goal
         developersPlan
         aiImplementationDetails
-        importantInstructionsAndPushbacks
-        frictionScore {
-          score
+        developersPushbacks
+        importantInstructionsAndDecisions
+        backAndForthLevel {
+          level
           justification
         }
       }
@@ -4644,6 +5915,7 @@ var REPORT_DEFAULT_FILE_NAME = "report.json";
 init_env();
 
 // src/features/analysis/scm/github/GithubSCMLib.ts
+import pLimit from "p-limit";
 import { z as z22 } from "zod";
 
 // src/features/analysis/scm/github/github.ts
@@ -4656,6 +5928,9 @@ import sodium from "libsodium-wrappers";
 import { Octokit } from "octokit";
 import { fetch as fetch2, ProxyAgent } from "undici";
 
+// src/features/analysis/scm/github/GithubSCMLib.ts
+var GITHUB_COMMIT_FETCH_CONCURRENCY = parseInt(process.env["GITHUB_COMMIT_CONCURRENCY"] || "10", 10) || 10;
+
 // src/features/analysis/scm/gitlab/gitlab.ts
 import querystring3 from "querystring";
 import {
@@ -5355,6 +6630,9 @@ async function handleMobbLogin({
   return newGqlClient;
 }
 
+// src/args/commands/upload_ai_blame.ts
+init_GitService();
+
 // src/features/analysis/upload-file.ts
 import Debug7 from "debug";
 import fetch3, { File, fileFrom, FormData } from "node-fetch";
@@ -5675,6 +6953,19 @@ var PromptItemZ = z26.object({
   }).optional()
 });
 var PromptItemArrayZ = z26.array(PromptItemZ);
+async function getRepositoryUrl() {
+  try {
+    const gitService = new GitService(process.cwd());
+    const isRepo = await gitService.isGitRepository();
+    if (!isRepo) {
+      return null;
+    }
+    const remoteUrl = await gitService.getRemoteUrl();
+    return isGitHubUrl(remoteUrl) ? remoteUrl : null;
+  } catch {
+    return null;
+  }
+}
 function getSystemInfo() {
   let userName;
   try {
@@ -5771,7 +7062,8 @@ async function uploadAiBlameHandlerFromExtension(args) {
         args: uploadArgs,
         exitOnError: false,
         apiUrl: args.apiUrl,
-        webAppUrl: args.webAppUrl
+        webAppUrl: args.webAppUrl,
+        repositoryUrl: args.repositoryUrl
       });
     });
   });
@@ -5807,6 +7099,7 @@ async function uploadAiBlameHandler(options) {
   }
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   const { computerName, userName } = getSystemInfo();
+  const repositoryUrl = options.repositoryUrl !== void 0 ? options.repositoryUrl : await getRepositoryUrl();
   const sessions = [];
   for (let i = 0; i < prompts.length; i++) {
     const promptPath = String(prompts[i]);
@@ -5833,7 +7126,8 @@ async function uploadAiBlameHandler(options) {
       blameType: blameTypes[i] || "CHAT" /* Chat */,
       computerName,
       userName,
-      sessionId: sessionIds[i]
+      sessionId: sessionIds[i],
+      repositoryUrl
     });
   }
   const authenticatedClient = await getAuthenticatedGQLClient({
@@ -5889,7 +7183,8 @@ async function uploadAiBlameHandler(options) {
       blameType: s.blameType,
       computerName: s.computerName,
       userName: s.userName,
-      sessionId: s.sessionId
+      sessionId: s.sessionId,
+      repositoryUrl: s.repositoryUrl
     };
   });
   try {