Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@98f8172e4753742f0e890cfc5ddd654e4ed66745

Author: github-actions[bot]

bun.lock

@@ -1,9 +1,10 @@
-import { describe, expect, test } from 'bun:test'
+import { beforeEach, describe, expect, test } from 'bun:test'
 
 import {
   getProjectPathLookupKeys,
   resolveFilePathWithinProject,
 } from '../tools/path-utils'
+import { resetTranslationCache } from '../tools/windows-bash'
 
 describe('resolveFilePathWithinProject', () => {
   test('normalizes relative paths to full and project-relative paths', () => {
@@ -56,3 +57,36 @@ describe('getProjectPathLookupKeys', () => {
     ])
   })
 })
+
+describe('getProjectPathLookupKeys with Git Bash paths', () => {
+  beforeEach(() => {
+    resetTranslationCache()
+  })
+
+  test('keys an out-of-project MSYS path by its translated path as well', () => {
+    expect(
+      getProjectPathLookupKeys('/repo', '/tmp/probe.txt', {
+        platform: 'win32',
+        env: {},
+        findBash: () => '/git/bin/bash.exe',
+        pathExists: () => true,
+        spawnCygpath: () => ({
+          status: 0,
+          stdout: '/msys-root/tmp/probe.txt\n',
+        }),
+      }),
+    ).toEqual(['/msys-root/tmp/probe.txt', '/tmp/probe.txt'])
+  })
+
+  test('translates an MSYS drive path without any bash lookup and keys by the native path', () => {
+    expect(
+      getProjectPathLookupKeys('/Users/me/repo', '/c/Users/me/repo/src/a.ts', {
+        platform: 'win32',
+        env: {},
+        findBash: () => {
+          throw new Error('drive paths must not need bash')
+        },
+      }),
+    ).toEqual(['C:\\Users\\me\\repo\\src\\a.ts', '/c/Users/me/repo/src/a.ts'])
+  })
+})

sdk/src/__tests__/path-utils.test.ts

@@ -9,7 +9,10 @@ import * as path from 'path'
 
 import {
   findWindowsBash,
+  isGitBashAbsolutePath,
   parseRegistryPath,
+  resetTranslationCache,
+  translateGitBashPath,
   windowsBashCandidates,
 } from '../tools/windows-bash'
 
@@ -222,3 +225,175 @@ describe('parseRegistryPath', () => {
     expect(parseRegistryPath('    InstallPath    REG_SZ    ', 'InstallPath')).toBeNull()
   })
 })
+
+describe('Git Bash path translation', () => {
+  beforeEach(() => {
+    resetTranslationCache()
+  })
+
+  it('recognizes MSYS absolute paths without claiming native UNC paths', () => {
+    expect(isGitBashAbsolutePath('/tmp/file.txt')).toBe(true)
+    expect(isGitBashAbsolutePath('/c/Users/Alice/file.txt')).toBe(true)
+    expect(isGitBashAbsolutePath('//server/share/file.txt')).toBe(false)
+    expect(isGitBashAbsolutePath('C:\\tmp\\file.txt')).toBe(false)
+    expect(isGitBashAbsolutePath('src/file.txt')).toBe(false)
+  })
+
+  it('translates a drive-letter MSYS path without any lookup or spawn', () => {
+    const neverFindBash = () => {
+      throw new Error('must not look for bash')
+    }
+    expect(
+      translateGitBashPath('/c/Users/me/repo/src/a.ts', {
+        platform: 'win32',
+        env: {},
+        findBash: neverFindBash,
+      }),
+    ).toBe('C:\\Users\\me\\repo\\src\\a.ts')
+    expect(
+      translateGitBashPath('/D/work/file.txt', {
+        platform: 'win32',
+        env: {},
+        findBash: neverFindBash,
+      }),
+    ).toBe('D:\\work\\file.txt')
+  })
+
+  it('spawns the cygpath.exe derived from the found bash, directly', () => {
+    const bash = path.join(installGitAt('Git'), 'bin', 'bash.exe')
+    const cygpath = touch(path.join(root, 'Git', 'usr', 'bin'), 'cygpath.exe')
+    const calls: [string, string][] = []
+
+    expect(
+      translateGitBashPath('/tmp/file.txt', {
+        platform: 'win32',
+        env: {},
+        findBash: () => bash,
+        spawnCygpath: (cygpath, filePath) => {
+          calls.push([cygpath, filePath])
+          return {
+            status: 0,
+            stdout: 'C:\\Users\\Alice\\AppData\\Local\\Temp\\file.txt\n',
+          }
+        },
+      }),
+    ).toBe('C:\\Users\\Alice\\AppData\\Local\\Temp\\file.txt')
+    expect(calls).toEqual([[cygpath, '/tmp/file.txt']])
+  })
+
+  it('spawns the cygpath.exe sitting beside a usr\\bin bash', () => {
+    const bash = touch(path.join(root, 'Git', 'usr', 'bin'), 'bash.exe')
+    const cygpath = touch(path.join(root, 'Git', 'usr', 'bin'), 'cygpath.exe')
+    const calls: [string, string][] = []
+
+    expect(
+      translateGitBashPath('/tmp/sibling.txt', {
+        platform: 'win32',
+        env: {},
+        findBash: () => bash,
+        spawnCygpath: (cygpath, filePath) => {
+          calls.push([cygpath, filePath])
+          return { status: 0, stdout: 'C:\\Temp\\sibling.txt\n' }
+        },
+      }),
+    ).toBe('C:\\Temp\\sibling.txt')
+    expect(calls).toEqual([[cygpath, '/tmp/sibling.txt']])
+  })
+
+  it('skips the spawn and keeps the original path when no cygpath.exe exists', () => {
+    const bash = touch(path.join(root, 'Git', 'bin'), 'bash.exe')
+    let spawns = 0
+
+    expect(
+      translateGitBashPath('/tmp/no-cygpath.txt', {
+        platform: 'win32',
+        env: {},
+        findBash: () => bash,
+        spawnCygpath: () => {
+          spawns++
+          return { status: 0, stdout: 'C:\\Temp\\no-cygpath.txt\n' }
+        },
+      }),
+    ).toBe('/tmp/no-cygpath.txt')
+    expect(spawns).toBe(0)
+  })
+
+  it('reads only the last stdout line, so leading banner output is ignored', () => {
+    expect(
+      translateGitBashPath('/tmp/banner.txt', {
+        platform: 'win32',
+        env: {},
+        findBash: () => path.join(root, 'Git', 'bin', 'bash.exe'),
+        pathExists: () => true,
+        spawnCygpath: () => ({
+          status: 0,
+          stdout:
+            'conda environment activated\nNow using node v22.1.0\nC:\\Temp\\banner.txt\r\n',
+        }),
+      }),
+    ).toBe('C:\\Temp\\banner.txt')
+  })
+
+  it('falls back to the original path on a non-zero exit even when stdout is non-empty', () => {
+    expect(
+      translateGitBashPath('/tmp/exit-code.txt', {
+        platform: 'win32',
+        env: {},
+        findBash: () => path.join(root, 'Git', 'bin', 'bash.exe'),
+        pathExists: () => true,
+        spawnCygpath: () => ({
+          status: 1,
+          stdout: 'C:\\Temp\\exit-code.txt\n',
+        }),
+      }),
+    ).toBe('/tmp/exit-code.txt')
+  })
+
+  it('spawns once per path and answers repeats from the cache', () => {
+    let spawns = 0
+    const dependencies = {
+      platform: 'win32' as NodeJS.Platform,
+      env: {},
+      findBash: () => path.join(root, 'Git', 'bin', 'bash.exe'),
+      pathExists: () => true,
+      spawnCygpath: () => {
+        spawns++
+        return { status: 0, stdout: 'C:\\Temp\\repeat.txt\n' }
+      },
+    }
+    expect(translateGitBashPath('/tmp/repeat.txt', dependencies)).toBe(
+      'C:\\Temp\\repeat.txt',
+    )
+    expect(translateGitBashPath('/tmp/repeat.txt', dependencies)).toBe(
+      'C:\\Temp\\repeat.txt',
+    )
+    expect(spawns).toBe(1)
+  })
+
+  it('leaves paths unchanged when translation does not apply or is unavailable', () => {
+    const neverFindBash = () => {
+      throw new Error('must not look for bash')
+    }
+    expect(
+      translateGitBashPath('/tmp/file.txt', {
+        platform: 'darwin',
+        findBash: neverFindBash,
+      }),
+    ).toBe('/tmp/file.txt')
+    expect(
+      translateGitBashPath('C:\\tmp\\file.txt', {
+        platform: 'win32',
+        findBash: neverFindBash,
+      }),
+    ).toBe('C:\\tmp\\file.txt')
+    expect(
+      translateGitBashPath('/tmp/file.txt', {
+        platform: 'win32',
+        env: {},
+        findBash: () => path.join(root, 'Git', 'bin', 'bash.exe'),
+        pathExists: () => true,
+        spawnCygpath: () => ({ status: 0, stdout: '' }),
+      }),
+    ).toBe('/tmp/file.txt')
+  })
+})

sdk/src/__tests__/windows-bash.test.ts

@@ -0,0 +1,45 @@
+import { expect, test } from 'bun:test'
+import { randomUUID } from 'crypto'
+import { promises as fs, rmSync } from 'fs'
+import { spawnSync } from 'child_process'
+
+import { getSystemProcessEnv } from '../env'
+import { getFiles } from '../tools/read-files'
+import { findWindowsBash, translateGitBashPath } from '../tools/windows-bash'
+
+const windowsTest = process.platform === 'win32' ? test : test.skip
+
+windowsTest(
+  'reads a file created under Git Bash /tmp with the native file tool',
+  async () => {
+    const bash = findWindowsBash(getSystemProcessEnv())
+    expect(bash).not.toBeNull()
+
+    const msysPath = `/tmp/freebuff-path-${randomUUID()}.txt`
+    const content = 'freebuff msys path probe'
+    const created = spawnSync(
+      bash!,
+      ['-lc', `printf '${content}' > '${msysPath}'`],
+      {
+        encoding: 'utf8',
+        windowsHide: true,
+      },
+    )
+    expect(created.status, created.stderr).toBe(0)
+
+    const nativePath = translateGitBashPath(msysPath)
+    expect(nativePath).not.toBe(msysPath)
+    try {
+      const result = await getFiles({
+        filePaths: [msysPath],
+        cwd: process.cwd(),
+        fs,
+        limitContent: false,
+        enforceEnvPolicy: false,
+      })
+      expect(Object.values(result)).toEqual([content])
+    } finally {
+      rmSync(nativePath, { force: true })
+    }
+  },
+)

sdk/src/__tests__/windows-msys-path.integration.test.ts

@@ -1,5 +1,9 @@
 import path from 'path'
 
+import { translateGitBashPath } from './windows-bash'
+
+import type { WindowsShellPathDependencies } from './windows-bash'
+
 export type ResolvedProjectPath = {
   fullPath: string
   relativePath: string
@@ -21,11 +25,13 @@ function escapesProject(relativePath: string): boolean {
 export function resolveFilePathWithinProject(
   projectRoot: string,
   filePath: string,
+  dependencies: WindowsShellPathDependencies = {},
 ): ResolvedProjectPath | null {
   const resolvedRoot = path.resolve(projectRoot)
-  const fullPath = path.isAbsolute(filePath)
-    ? path.resolve(filePath)
-    : path.resolve(resolvedRoot, filePath)
+  const nativeFilePath = translateGitBashPath(filePath, dependencies)
+  const fullPath = path.isAbsolute(nativeFilePath)
+    ? path.resolve(nativeFilePath)
+    : path.resolve(resolvedRoot, nativeFilePath)
   const relativePath = path.relative(resolvedRoot, fullPath)
 
   if (relativePath === '' || escapesProject(relativePath)) {
@@ -43,15 +49,20 @@ export function resolveFilePathWithinProject(
  * when the target is inside the project, otherwise the absolute path.
  * `isWithinProject` lets callers skip project-scoped logic (e.g. gitignore) for
  * files that live outside the project.
+ * On Windows, a single-leading-slash path uses Git Bash semantics because that
+ * is the shell exposed to agents; native absolute paths retain their drive or
+ * UNC prefix.
  */
 export function resolveFilePath(
   projectRoot: string,
   filePath: string,
+  dependencies: WindowsShellPathDependencies = {},
 ): ResolvedFilePath {
   const resolvedRoot = path.resolve(projectRoot)
-  const fullPath = path.isAbsolute(filePath)
-    ? path.resolve(filePath)
-    : path.resolve(resolvedRoot, filePath)
+  const nativeFilePath = translateGitBashPath(filePath, dependencies)
+  const fullPath = path.isAbsolute(nativeFilePath)
+    ? path.resolve(nativeFilePath)
+    : path.resolve(resolvedRoot, nativeFilePath)
   const relativePath = path.relative(resolvedRoot, fullPath)
   const isWithinProject = relativePath !== '' && !escapesProject(relativePath)
   const displayPath = isWithinProject ? relativePath : fullPath
@@ -62,9 +73,19 @@ export function resolveFilePath(
 export function getProjectPathLookupKeys(
   projectRoot: string,
   filePath: string,
+  dependencies: WindowsShellPathDependencies = {},
 ): string[] {
-  const resolvedPath = resolveFilePathWithinProject(projectRoot, filePath)
-  const keys = resolvedPath ? [resolvedPath.relativePath, filePath] : [filePath]
+  const resolvedPath = resolveFilePathWithinProject(
+    projectRoot,
+    filePath,
+    dependencies,
+  )
+  const keys = resolvedPath
+    ? [resolvedPath.relativePath, filePath]
+    : [
+        resolveFilePath(projectRoot, filePath, dependencies).relativePath,
+        filePath,
+      ]
 
   return [...new Set(keys)]
 }