version 1.3.4

Author: Kirill89

__tests__/parseGitBlamePorcelain-rename.test.ts

@@ -0,0 +1,221 @@
+import { execSync } from 'node:child_process'
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+import {
+  buildGitBlameArgs,
+  parseGitBlamePorcelainByLine,
+} from '@mobb/bugsy/utils/blame/gitBlameUtils'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+
+/**
+ * These tests spawn a real `git` process against temp repos we create on
+ * the fly and feed the raw porcelain output through the exact function
+ * the production blame pipeline uses. Hand-crafted fixture strings would
+ * silently drift out of sync with git's actual output; this harness
+ * catches that drift.
+ */
+
+type GitEnv = NodeJS.ProcessEnv
+
+const gitEnv: GitEnv = {
+  ...process.env,
+  GIT_AUTHOR_NAME: 'Test',
+  GIT_AUTHOR_EMAIL: 'test@test.com',
+  GIT_COMMITTER_NAME: 'Test',
+  GIT_COMMITTER_EMAIL: 'test@test.com',
+  // Prevent global git config (hooks, signing, templates) from interfering.
+  GIT_CONFIG_GLOBAL: '/dev/null',
+  GIT_CONFIG_SYSTEM: '/dev/null',
+}
+
+function git(cwd: string, args: string[]): string {
+  return execSync(
+    ['git', ...args].map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(' '),
+    {
+      cwd,
+      env: gitEnv,
+      encoding: 'utf8',
+    }
+  )
+}
+
+async function writeFile(repo: string, relPath: string, content: string) {
+  const abs = path.join(repo, relPath)
+  await fs.mkdir(path.dirname(abs), { recursive: true })
+  await fs.writeFile(abs, content)
+}
+
+async function initRepo(): Promise<string> {
+  const repo = await fs.mkdtemp(path.join(os.tmpdir(), 'blame-rename-test-'))
+  git(repo, ['init', '--initial-branch=main'])
+  return repo
+}
+
+function headSha(repo: string): string {
+  return git(repo, ['rev-parse', 'HEAD']).trim()
+}
+
+function runBlame(repo: string, filePath: string, baseRef: string): string {
+  const args = buildGitBlameArgs({
+    mode: 'diffRange',
+    filePath,
+    baseRef,
+    headRef: 'HEAD',
+  })
+  return execSync(
+    ['git', ...args].map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(' '),
+    {
+      cwd: repo,
+      env: gitEnv,
+      encoding: 'utf8',
+    }
+  )
+}
+
+describe('parseGitBlamePorcelainByLine — rename scenarios', () => {
+  describe('scenario 1: non-merge pure rename (git mv)', () => {
+    let repo: string
+    let base: string
+    let commitAddFile: string
+    const addedLines = [
+      'line one',
+      'line two',
+      'line three',
+      'line four',
+      'line five',
+    ]
+
+    beforeAll(async () => {
+      repo = await initRepo()
+      // Commit 1: establish a base commit so blame has a diff range to walk
+      await writeFile(repo, 'README.md', 'initial\n')
+      git(repo, ['add', '.'])
+      git(repo, ['commit', '-m', 'base'])
+      base = headSha(repo)
+
+      // Commit 2: add foo.ts with 5 lines — this is the authoring commit
+      await writeFile(repo, 'foo.ts', addedLines.join('\n') + '\n')
+      git(repo, ['add', 'foo.ts'])
+      git(repo, ['commit', '-m', 'add foo.ts'])
+      commitAddFile = headSha(repo)
+
+      // Commit 3: pure rename, no content change
+      git(repo, ['mv', 'foo.ts', 'bar.ts'])
+      git(repo, ['commit', '-m', 'rename foo -> bar'])
+    })
+
+    afterAll(async () => {
+      await fs.rm(repo, { recursive: true, force: true })
+    })
+
+    it('traces every blamed line back to the authoring commit and reports the pre-rename path', () => {
+      const raw = runBlame(repo, 'bar.ts', base)
+      const lines = parseGitBlamePorcelainByLine(raw)
+
+      const results = Object.values(lines)
+      expect(results.length).toBe(addedLines.length)
+      for (const info of results) {
+        expect(info.commit).toBe(commitAddFile)
+        // The whole point of the test: `-M` + porcelain `filename` must
+        // give us the pre-rename path, not the current path.
+        expect(info.originalFile).toBe('foo.ts')
+      }
+    })
+  })
+
+  describe('scenario 2: merge-conflict rename (PR #3596 pattern)', () => {
+    let repo: string
+    let featureCommit: string
+    let base: string
+    const fileContent =
+      Array.from({ length: 10 }, (_, i) => `line ${i + 1}`).join('\n') + '\n'
+
+    beforeAll(async () => {
+      repo = await initRepo()
+      // Base commit on main
+      await writeFile(repo, 'README.md', 'initial\n')
+      git(repo, ['add', '.'])
+      git(repo, ['commit', '-m', 'base'])
+      base = headSha(repo)
+
+      // Feature branch: add test-1-16.ts
+      git(repo, ['checkout', '-b', 'feature'])
+      await writeFile(repo, 'test-1-16.ts', fileContent)
+      git(repo, ['add', '.'])
+      git(repo, ['commit', '-m', 'add test-1-16'])
+      featureCommit = headSha(repo)
+
+      // Main branch moves forward with an unrelated change
+      git(repo, ['checkout', 'main'])
+      await writeFile(repo, 'other.ts', 'unrelated main work\n')
+      git(repo, ['add', '.'])
+      git(repo, ['commit', '-m', 'unrelated main change'])
+
+      // Back on feature: merge main in with a conflict-resolution rename.
+      // Simulate by first merging (no actual conflict since files differ),
+      // then renaming to test-1-17 in a commit that represents the
+      // resolution. The merge does encode the content-path history git
+      // needs to trace blame correctly.
+      git(repo, ['checkout', 'feature'])
+      git(repo, ['merge', '--no-edit', 'main'])
+      // Rename test-1-16 -> test-1-17 to mirror the real PR
+      git(repo, ['mv', 'test-1-16.ts', 'test-1-17.ts'])
+      git(repo, ['commit', '-m', 'rename test-1-16 -> test-1-17'])
+    })
+
+    afterAll(async () => {
+      await fs.rm(repo, { recursive: true, force: true })
+    })
+
+    it('traces every unchanged line back to the feature commit with the pre-rename path', () => {
+      const raw = runBlame(repo, 'test-1-17.ts', base)
+      const lines = parseGitBlamePorcelainByLine(raw)
+
+      const results = Object.values(lines)
+      expect(results.length).toBe(10)
+      for (const info of results) {
+        expect(info.commit).toBe(featureCommit)
+        // The critical assertion: the historical path is the pre-rename
+        // name, which is what the attribution rows are keyed by.
+        expect(info.originalFile).toBe('test-1-16.ts')
+      }
+    })
+  })
+
+  describe('scenario 3: baseline (no rename)', () => {
+    let repo: string
+    let base: string
+    let commitAddFile: string
+
+    beforeAll(async () => {
+      repo = await initRepo()
+      await writeFile(repo, 'README.md', 'initial\n')
+      git(repo, ['add', '.'])
+      git(repo, ['commit', '-m', 'base'])
+      base = headSha(repo)
+
+      await writeFile(repo, 'baseline.ts', 'line one\nline two\nline three\n')
+      git(repo, ['add', '.'])
+      git(repo, ['commit', '-m', 'add baseline'])
+      commitAddFile = headSha(repo)
+    })
+
+    afterAll(async () => {
+      await fs.rm(repo, { recursive: true, force: true })
+    })
+
+    it('reports the current path as the historical path (no rename)', () => {
+      const raw = runBlame(repo, 'baseline.ts', base)
+      const lines = parseGitBlamePorcelainByLine(raw)
+
+      const results = Object.values(lines)
+      expect(results.length).toBe(3)
+      for (const info of results) {
+        expect(info.commit).toBe(commitAddFile)
+        expect(info.originalFile).toBe('baseline.ts')
+      }
+    })
+  })
+})

__tests__/parseGitBlamePorcelain.test.ts

@@ -39,5 +39,9 @@ describe('parseGitBlamePorcelain', () => {
     expect(lineInfo?.authorName).toBeTypeOf('string')
     expect(lineInfo?.authorEmail).toBeTypeOf('string')
     expect(lineInfo?.authorTime).toBeGreaterThan(1600000000)
+    // The asset file has not been renamed, so porcelain should report
+    // its current path as the historical path.
+    expect(lineInfo?.originalFile).toBeTypeOf('string')
+    expect(lineInfo?.originalFile).toContain('SigningAssignment.java')
   })
 })

package.json

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

src/args/commands/upload_ai_blame.ts

@@ -124,6 +124,26 @@ export async function getRepositoryUrl(
   }
 }
 
+/**
+ * Gets the absolute git root path of the working directory's git checkout.
+ * Used by Tracy uploads to let the server filter out events whose filePath
+ * falls outside the repo (e.g., /tmp scratchpads, ~/.zshrc).
+ */
+export async function getRepoGitRoot(
+  workingDir?: string
+): Promise<string | null> {
+  try {
+    const gitService = new GitService(workingDir ?? process.cwd())
+    const isRepo = await gitService.isGitRepository()
+    if (!isRepo) {
+      return null
+    }
+    return await gitService.getGitRoot()
+  } catch {
+    return null
+  }
+}
+
 /**
  * Get system information for tracking inference source.
  * Works cross-platform (Windows, macOS, Linux).

src/features/analysis/graphql/tracy-batch-upload.ts

@@ -1,6 +1,7 @@
 import Debug from 'debug'
 
 import {
+  getRepoGitRoot,
   getRepositoryUrl,
   getSystemInfo,
 } from '../../../args/commands/upload_ai_blame'
@@ -37,13 +38,16 @@ export type TracyRecordClientInput = Omit<
   TracyRecordInput,
   | 'rawDataS3Key'
   | 'repositoryUrl'
+  | 'gitRoot'
   | 'computerName'
   | 'userName'
   | 'clientVersion'
 > & {
   rawData?: unknown // object from extension, will be sanitized & serialized
   /** Override auto-detected repo URL (e.g. from extension metadata) */
   repositoryUrl?: string
+  /** Override auto-detected git root (e.g. from extension metadata) */
+  gitRoot?: string
   /** Override auto-detected client version (e.g. extension version instead of CLI version) */
   clientVersion?: string
 }
@@ -90,6 +94,11 @@ export async function prepareAndSendTracyRecords(
     ? undefined
     : ((await getRepositoryUrl(workingDir)) ?? undefined)
 
+  // Only resolve default git root if the caller didn't provide one per-record.
+  const defaultGitRoot = rawRecords[0]?.gitRoot
+    ? undefined
+    : ((await getRepoGitRoot(workingDir)) ?? undefined)
+
   // 1. Enrich records and optionally sanitize rawData
   debug(
     '[step:sanitize] %s %d records',
@@ -113,6 +122,7 @@ export async function prepareAndSendTracyRecords(
           return {
             ...rest,
             repositoryUrl: record.repositoryUrl ?? defaultRepoUrl,
+            gitRoot: record.gitRoot ?? defaultGitRoot,
             computerName,
             userName,
             clientVersion: record.clientVersion ?? defaultClientVersion,