@miaws/miaw 1.18.5 → 1.18.6

package/test/lsp/index.test.ts

@@ -1,232 +0,0 @@
-import { describe, expect, spyOn } from "bun:test"
-import path from "path"
-import { Deferred, Effect, Layer } from "effect"
-import { EventV2Bridge } from "@/event-v2-bridge"
-import { Config } from "@/config/config"
-import { RuntimeFlags } from "@/effect/runtime-flags"
-import { LSP } from "@/lsp/lsp"
-import * as LSPServer from "@/lsp/server"
-import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
-import { TestInstance } from "../fixture/fixture"
-import { awaitWithTimeout, testEffect } from "../lib/effect"
-
-const lspLayer = (flags: Parameters<typeof RuntimeFlags.layer>[0] = {}) =>
-  LSP.layer.pipe(
-    Layer.provide(Config.defaultLayer),
-    Layer.provide(RuntimeFlags.layer(flags)),
-    Layer.provideMerge(EventV2Bridge.defaultLayer),
-  )
-
-const it = testEffect(Layer.mergeAll(lspLayer(), CrossSpawnSpawner.defaultLayer))
-const experimentalTyIt = testEffect(
-  Layer.mergeAll(lspLayer({ experimentalLspTy: true }), CrossSpawnSpawner.defaultLayer),
-)
-const fakeServerPath = path.join(__dirname, "../fixture/lsp/fake-lsp-server.js")
-const disabledDownloadIt = testEffect(
-  Layer.mergeAll(lspLayer({ disableLspDownload: true }), CrossSpawnSpawner.defaultLayer),
-)
-
-describe("lsp.spawn", () => {
-  it.instance(
-    "does not spawn builtin LSP for files outside instance",
-    () =>
-      LSP.Service.use((lsp) =>
-        Effect.gen(function* () {
-          const dir = (yield* TestInstance).directory
-          const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
-
-          try {
-            yield* lsp.touchFile(path.join(dir, "..", "outside.ts"))
-            yield* lsp.hover({
-              file: path.join(dir, "..", "hover.ts"),
-              line: 0,
-              character: 0,
-            })
-            expect(spy).toHaveBeenCalledTimes(0)
-          } finally {
-            spy.mockRestore()
-          }
-        }),
-      ),
-    { config: { lsp: true } },
-  )
-
-  it.instance("does not spawn builtin LSP for files inside instance when LSP is unset", () =>
-    LSP.Service.use((lsp) =>
-      Effect.gen(function* () {
-        const dir = (yield* TestInstance).directory
-        const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
-
-        try {
-          yield* lsp.hover({
-            file: path.join(dir, "src", "inside.ts"),
-            line: 0,
-            character: 0,
-          })
-          expect(spy).toHaveBeenCalledTimes(0)
-        } finally {
-          spy.mockRestore()
-        }
-      }),
-    ),
-  )
-
-  it.instance(
-    "would spawn builtin LSP for files inside instance when lsp is true",
-    () =>
-      LSP.Service.use((lsp) =>
-        Effect.gen(function* () {
-          const dir = (yield* TestInstance).directory
-          const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
-
-          try {
-            yield* lsp.hover({
-              file: path.join(dir, "src", "inside.ts"),
-              line: 0,
-              character: 0,
-            })
-            expect(spy).toHaveBeenCalledTimes(1)
-          } finally {
-            spy.mockRestore()
-          }
-        }),
-      ),
-    { config: { lsp: true } },
-  )
-
-  it.instance(
-    "publishes lsp.updated after custom LSP initialization",
-    () =>
-      Effect.gen(function* () {
-        const dir = (yield* TestInstance).directory
-        const lsp = yield* LSP.Service
-        const updated = yield* Deferred.make<void>()
-        const events = yield* EventV2Bridge.Service
-        const unsubscribe = yield* events.listen((event) => {
-          if (event.type === LSP.Event.Updated.type) Deferred.doneUnsafe(updated, Effect.void)
-          return Effect.void
-        })
-        yield* Effect.addFinalizer(() => unsubscribe)
-
-        const file = path.join(dir, "sample.repro")
-        yield* Effect.promise(() => Bun.write(file, "sample\n"))
-        yield* lsp.touchFile(file)
-        yield* awaitWithTimeout(Deferred.await(updated), "lsp.updated event was not published")
-      }),
-    {
-      config: {
-        lsp: {
-          fake: {
-            command: [process.execPath, fakeServerPath],
-            extensions: [".repro"],
-          },
-        },
-      },
-    },
-  )
-
-  it.instance(
-    "would spawn builtin LSP for files inside instance when config object is provided",
-    () =>
-      LSP.Service.use((lsp) =>
-        Effect.gen(function* () {
-          const dir = (yield* TestInstance).directory
-          const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
-
-          try {
-            yield* lsp.hover({
-              file: path.join(dir, "src", "inside.ts"),
-              line: 0,
-              character: 0,
-            })
-            expect(spy).toHaveBeenCalledTimes(1)
-          } finally {
-            spy.mockRestore()
-          }
-        }),
-      ),
-    {
-      config: {
-        lsp: {
-          eslint: { disabled: true },
-        },
-      },
-    },
-  )
-
-  it.instance(
-    "uses pyright instead of ty by default",
-    () =>
-      LSP.Service.use((lsp) =>
-        Effect.gen(function* () {
-          const dir = (yield* TestInstance).directory
-          const ty = spyOn(LSPServer.Ty, "spawn").mockResolvedValue(undefined)
-          const pyright = spyOn(LSPServer.Pyright, "spawn").mockResolvedValue(undefined)
-
-          try {
-            yield* lsp.hover({
-              file: path.join(dir, "src", "inside.py"),
-              line: 0,
-              character: 0,
-            })
-            expect(ty).toHaveBeenCalledTimes(0)
-            expect(pyright).toHaveBeenCalledTimes(1)
-          } finally {
-            ty.mockRestore()
-            pyright.mockRestore()
-          }
-        }),
-      ),
-    { config: { lsp: true } },
-  )
-
-  experimentalTyIt.instance(
-    "uses ty instead of pyright when experimentalLspTy is enabled",
-    () =>
-      LSP.Service.use((lsp) =>
-        Effect.gen(function* () {
-          const dir = (yield* TestInstance).directory
-          const ty = spyOn(LSPServer.Ty, "spawn").mockResolvedValue(undefined)
-          const pyright = spyOn(LSPServer.Pyright, "spawn").mockResolvedValue(undefined)
-
-          try {
-            yield* lsp.hover({
-              file: path.join(dir, "src", "inside.py"),
-              line: 0,
-              character: 0,
-            })
-            expect(ty).toHaveBeenCalledTimes(1)
-            expect(pyright).toHaveBeenCalledTimes(0)
-          } finally {
-            ty.mockRestore()
-            pyright.mockRestore()
-          }
-        }),
-      ),
-    { config: { lsp: true } },
-  )
-
-  disabledDownloadIt.instance(
-    "passes disableLspDownload to builtin LSP spawn",
-    () =>
-      LSP.Service.use((lsp) =>
-        Effect.gen(function* () {
-          const dir = (yield* TestInstance).directory
-          const pyright = spyOn(LSPServer.Pyright, "spawn").mockResolvedValue(undefined)
-
-          try {
-            yield* lsp.hover({
-              file: path.join(dir, "src", "inside.py"),
-              line: 0,
-              character: 0,
-            })
-            expect(pyright).toHaveBeenCalledTimes(1)
-            expect(pyright.mock.calls[0]?.[2]).toMatchObject({ disableLspDownload: true })
-          } finally {
-            pyright.mockRestore()
-          }
-        }),
-      ),
-    { config: { lsp: true } },
-  )
-})

package/test/lsp/jdtls-root.test.ts

@@ -1,459 +0,0 @@
-import { describe, test, expect, afterAll } from "bun:test"
-import path from "path"
-import fs from "fs/promises"
-import os from "os"
-import * as LSPServer from "@/lsp/server"
-import type { InstanceContext } from "@/project/instance-context"
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const tmpBase = path.join(os.tmpdir(), "miaw-jdtls-test")
-
-function makeCtx(directory: string): InstanceContext {
-  return { directory, worktree: "/", project: {} as any }
-}
-
-async function mkdirp(p: string) {
-  await fs.mkdir(p, { recursive: true })
-}
-
-async function touch(p: string) {
-  await mkdirp(path.dirname(p))
-  await fs.writeFile(p, "", "utf-8")
-}
-
-// ---------------------------------------------------------------------------
-// Cleanup
-// ---------------------------------------------------------------------------
-
-afterAll(async () => {
-  await fs.rm(tmpBase, { recursive: true, force: true }).catch(() => {})
-})
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("JDTLS.root", () => {
-  // -------------------------------------------------------------------------
-  // Maven
-  // -------------------------------------------------------------------------
-  describe("Maven", () => {
-    test("single-module Maven project returns pom.xml directory", async () => {
-      const root = path.join(tmpBase, "single-maven")
-      await mkdirp(root)
-      await touch(path.join(root, "pom.xml"))
-      const srcDir = path.join(root, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      expect(result).toBe(root)
-    })
-
-    test("multi-module Maven project follows <module> chain to top-level pom.xml", async () => {
-      const root = path.join(tmpBase, "multi-maven")
-      await mkdirp(root)
-      // Parent pom with <module>module-a</module>
-      await Bun.write(path.join(root, "pom.xml"), "<project><modules><module>module-a</module></modules></project>")
-      // Child module with its own pom.xml
-      const childDir = path.join(root, "module-a")
-      await mkdirp(childDir)
-      await touch(path.join(childDir, "pom.xml"))
-      const srcDir = path.join(childDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      // Parent declares module-a as module → root is parent directory
-      expect(result).toBe(root)
-    })
-
-    test("Maven project inside a nested directory (ctx.directory is workspace root)", async () => {
-      // Workspace root = ctx.directory, Maven project in a subdirectory
-      const workspace = path.join(tmpBase, "maven-workspace")
-      await mkdirp(workspace)
-      const projectDir = path.join(workspace, "my-maven-app")
-      await touch(path.join(projectDir, "pom.xml"))
-      const srcDir = path.join(projectDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(workspace))
-      // findUp finds projectDir's pom.xml (only one), returns projectDir
-      expect(result).toBe(projectDir)
-    })
-
-    test("nested independent Maven project stops at its own pom.xml", async () => {
-      const workspace = path.join(tmpBase, "nested-independent")
-      await mkdirp(workspace)
-      // Parent pom WITHOUT <module>tools/sample</module>
-      await Bun.write(
-        path.join(workspace, "pom.xml"),
-        "<project><modules><module>module-a</module></modules></project>",
-      )
-      // Independent project nested inside
-      const projectDir = path.join(workspace, "tools", "sample")
-      await mkdirp(projectDir)
-      await touch(path.join(projectDir, "pom.xml"))
-      const srcDir = path.join(projectDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(workspace))
-      // workspace/pom.xml does NOT declare tools/sample as module → stop at tools/sample
-      expect(result).toBe(projectDir)
-    })
-
-    test("three-level Maven module chain resolves to top-level", async () => {
-      const root = path.join(tmpBase, "three-level")
-      await mkdirp(root)
-      await Bun.write(path.join(root, "pom.xml"), "<project><modules><module>apps</module></modules></project>")
-      const appsDir = path.join(root, "apps")
-      await mkdirp(appsDir)
-      await Bun.write(path.join(appsDir, "pom.xml"), "<project><modules><module>my-app</module></modules></project>")
-      const appDir = path.join(appsDir, "my-app")
-      await mkdirp(appDir)
-      await touch(path.join(appDir, "pom.xml"))
-      const srcDir = path.join(appDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      expect(result).toBe(root)
-    })
-
-    test("three-level Maven chain stops when <module> link is broken", async () => {
-      const root = path.join(tmpBase, "broken-chain")
-      await mkdirp(root)
-      await Bun.write(path.join(root, "pom.xml"), "<project><modules><module>apps</module></modules></project>")
-      const appsDir = path.join(root, "apps")
-      await mkdirp(appsDir)
-      await touch(path.join(appsDir, "pom.xml")) // Empty pom, no <module> declaration
-      const appDir = path.join(appsDir, "my-app")
-      await mkdirp(appDir)
-      await touch(path.join(appDir, "pom.xml"))
-      const srcDir = path.join(appDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      // apps/pom.xml has no <module>my-app</module> → stop at my-app
-      expect(result).toBe(appDir)
-    })
-
-    test("<module> with ./ prefix is normalized correctly", async () => {
-      const root = path.join(tmpBase, "dot-slash-module")
-      await mkdirp(root)
-      await Bun.write(path.join(root, "pom.xml"), "<project><modules><module>./module-a</module></modules></project>")
-      const childDir = path.join(root, "module-a")
-      await mkdirp(childDir)
-      await touch(path.join(childDir, "pom.xml"))
-      const srcDir = path.join(childDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      expect(result).toBe(root)
-    })
-
-    test("<module> with trailing slash is normalized correctly", async () => {
-      const root = path.join(tmpBase, "trailing-slash-module")
-      await mkdirp(root)
-      await Bun.write(path.join(root, "pom.xml"), "<project><modules><module>module-a/</module></modules></project>")
-      const childDir = path.join(root, "module-a")
-      await mkdirp(childDir)
-      await touch(path.join(childDir, "pom.xml"))
-      const srcDir = path.join(childDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      expect(result).toBe(root)
-    })
-  })
-
-  // -------------------------------------------------------------------------
-  // Gradle
-  // -------------------------------------------------------------------------
-  describe("Gradle", () => {
-    test("Gradle project with settings.gradle in a subdirectory of ctx.directory", async () => {
-      // Workspace root = ctx.directory, Gradle project in a subdirectory
-      const workspace = path.join(tmpBase, "gradle-sub")
-      await mkdirp(workspace)
-      const projectDir = path.join(workspace, "gradle-app")
-      await touch(path.join(projectDir, "settings.gradle"))
-      await touch(path.join(projectDir, "build.gradle"))
-      const srcDir = path.join(projectDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(workspace))
-      expect(result).toBe(projectDir)
-    })
-
-    test("Gradle project with only build.gradle in a subdirectory", async () => {
-      const workspace = path.join(tmpBase, "gradle-build-sub")
-      await mkdirp(workspace)
-      const projectDir = path.join(workspace, "gradle-app")
-      await touch(path.join(projectDir, "build.gradle"))
-      const srcDir = path.join(projectDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(workspace))
-      expect(result).toBe(projectDir)
-    })
-
-    test("Gradle monorepo with settings.gradle takes precedence over nested pom.xml", async () => {
-      const workspace = path.join(tmpBase, "gradle-monorepo")
-      await mkdirp(workspace)
-      const gradleRoot = path.join(workspace, "gradle-project")
-      await touch(path.join(gradleRoot, "settings.gradle"))
-      await touch(path.join(gradleRoot, "gradlew"))
-      // Submodule has pom.xml too
-      const subDir = path.join(gradleRoot, "module-a")
-      await mkdirp(subDir)
-      await touch(path.join(subDir, "pom.xml"))
-      const srcDir = path.join(subDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(workspace))
-      // Gradle markers found at gradleRoot level
-      expect(result).toBe(gradleRoot)
-    })
-
-    test("settings.gradle.kts (Kotlin DSL) is recognized", async () => {
-      const workspace = path.join(tmpBase, "gradle-kts-settings")
-      await mkdirp(workspace)
-      const projectDir = path.join(workspace, "gradle-app")
-      await touch(path.join(projectDir, "settings.gradle.kts"))
-      const srcDir = path.join(projectDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(workspace))
-      expect(result).toBe(projectDir)
-    })
-
-    test("build.gradle.kts (Kotlin DSL) is recognized", async () => {
-      const workspace = path.join(tmpBase, "gradle-kts-build")
-      await mkdirp(workspace)
-      const projectDir = path.join(workspace, "gradle-app")
-      await touch(path.join(projectDir, "build.gradle.kts"))
-      const srcDir = path.join(projectDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(workspace))
-      expect(result).toBe(projectDir)
-    })
-
-    test("gradlew (without settings.gradle) in a subdirectory is recognized", async () => {
-      const workspace = path.join(tmpBase, "gradlew-sub")
-      await mkdirp(workspace)
-      const projectDir = path.join(workspace, "gradle-app")
-      await touch(path.join(projectDir, "gradlew"))
-      const srcDir = path.join(projectDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(workspace))
-      expect(result).toBe(projectDir)
-    })
-
-    test("pom.xml is excluded when gradlew is present at same level", async () => {
-      const workspace = path.join(tmpBase, "gradle-excludes-maven")
-      await mkdirp(workspace)
-      const projectDir = path.join(workspace, "mixed-project")
-      // Both pom.xml and gradlew exist
-      await touch(path.join(projectDir, "pom.xml"))
-      await touch(path.join(projectDir, "gradlew"))
-      const srcDir = path.join(projectDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(workspace))
-      // Gradle wrapper takes precedence
-      expect(result).toBe(projectDir)
-    })
-  })
-
-  // -------------------------------------------------------------------------
-  // Eclipse
-  // -------------------------------------------------------------------------
-  describe("Eclipse", () => {
-    test("Eclipse project with .project in a subdirectory", async () => {
-      const workspace = path.join(tmpBase, "eclipse-sub")
-      await mkdirp(workspace)
-      const projectDir = path.join(workspace, "eclipse-app")
-      await touch(path.join(projectDir, ".project"))
-      await touch(path.join(projectDir, ".classpath"))
-      const srcDir = path.join(projectDir, "src", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(workspace))
-      expect(result).toBe(projectDir)
-    })
-  })
-
-  // -------------------------------------------------------------------------
-  // No markers
-  // -------------------------------------------------------------------------
-  describe("No build markers", () => {
-    test("Java file with no build markers returns undefined", async () => {
-      const root = path.join(tmpBase, "no-build")
-      await mkdirp(root)
-      const srcDir = path.join(root, "src")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      expect(result).toBeUndefined()
-    })
-  })
-
-  // -------------------------------------------------------------------------
-  // Additional validation scenarios
-  // -------------------------------------------------------------------------
-  describe("Additional Maven module-chain validation", () => {
-    // Scenario 1: <module> with multi-segment path (e.g. <module>tools/sample</module>)
-    test("<module> multi-segment path matches nested directory", async () => {
-      const root = path.join(tmpBase, "multi-seg-module")
-      await mkdirp(root)
-      await Bun.write(path.join(root, "pom.xml"), "<project><modules><module>tools/sample</module></modules></project>")
-      const childDir = path.join(root, "tools", "sample")
-      await mkdirp(childDir)
-      await touch(path.join(childDir, "pom.xml"))
-      const srcDir = path.join(childDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      expect(result).toBe(root)
-    })
-
-    // Scenario 2: <module> declaration does not match actual directory name
-    test("<module> declaration mismatch does not falsely match", async () => {
-      const root = path.join(tmpBase, "module-mismatch")
-      await mkdirp(root)
-      // Parent declares module-a, but actual directory is module-b
-      await Bun.write(path.join(root, "pom.xml"), "<project><modules><module>module-a</module></modules></project>")
-      const childDir = path.join(root, "module-b")
-      await mkdirp(childDir)
-      await touch(path.join(childDir, "pom.xml"))
-      const srcDir = path.join(childDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      // module-b is not declared as a module → stop at module-b
-      expect(result).toBe(childDir)
-    })
-
-    // Scenario 3: Multiple <module> declarations
-    test("multiple <module> declarations allow second module to traverse up", async () => {
-      const root = path.join(tmpBase, "multi-modules")
-      await mkdirp(root)
-      await Bun.write(
-        path.join(root, "pom.xml"),
-        "<project><modules><module>module-a</module><module>module-b</module></modules></project>",
-      )
-      const childA = path.join(root, "module-a")
-      await mkdirp(childA)
-      await touch(path.join(childA, "pom.xml"))
-      const childB = path.join(root, "module-b")
-      await mkdirp(childB)
-      await touch(path.join(childB, "pom.xml"))
-      const srcDir = path.join(childB, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      expect(result).toBe(root)
-    })
-
-    // Scenario 4: XML comments should not be matched as module declarations
-    test("XML-commented <module> is not matched", async () => {
-      const root = path.join(tmpBase, "commented-module")
-      await mkdirp(root)
-      await Bun.write(
-        path.join(root, "pom.xml"),
-        "<project><modules><!-- <module>module-a</module> --></modules></project>",
-      )
-      const childDir = path.join(root, "module-a")
-      await mkdirp(childDir)
-      await touch(path.join(childDir, "pom.xml"))
-      const srcDir = path.join(childDir, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      // Commented-out module should not be matched → stop at module-a
-      expect(result).toBe(childDir)
-    })
-
-    // Scenario 5: pom.xml at ctx.directory itself
-    test("pom.xml at ctx.directory itself is found correctly", async () => {
-      const root = path.join(tmpBase, "pom-at-ctx")
-      await mkdirp(root)
-      await touch(path.join(root, "pom.xml"))
-      const srcDir = path.join(root, "src", "main", "java", "com", "example")
-      await mkdirp(srcDir)
-      await touch(path.join(srcDir, "App.java"))
-
-      const file = path.join(srcDir, "App.java")
-      const result = await LSPServer.JDTLS.root(file, makeCtx(root))
-      expect(result).toBe(root)
-    })
-
-    // Scenario 6: Mixed Gradle + Maven sibling projects don't interfere
-    test("Maven and Gradle sibling projects don't interfere", async () => {
-      const workspace = path.join(tmpBase, "mixed-siblings")
-      await mkdirp(workspace)
-      // Gradle project
-      const gradleDir = path.join(workspace, "gradle-project")
-      await touch(path.join(gradleDir, "settings.gradle"))
-      const gradleSrc = path.join(gradleDir, "src", "main", "java", "com", "example")
-      await mkdirp(gradleSrc)
-      await touch(path.join(gradleSrc, "GradleApp.java"))
-      // Maven project
-      const mavenDir = path.join(workspace, "maven-project")
-      await touch(path.join(mavenDir, "pom.xml"))
-      const mavenSrc = path.join(mavenDir, "src", "main", "java", "com", "example")
-      await mkdirp(mavenSrc)
-      await touch(path.join(mavenSrc, "MavenApp.java"))
-
-      const gradleResult = await LSPServer.JDTLS.root(path.join(gradleSrc, "GradleApp.java"), makeCtx(workspace))
-      expect(gradleResult).toBe(gradleDir)
-
-      const mavenResult = await LSPServer.JDTLS.root(path.join(mavenSrc, "MavenApp.java"), makeCtx(workspace))
-      expect(mavenResult).toBe(mavenDir)
-    })
-  })
-})