saeeol 1.2.9 → 1.3.1

package/test/format/format.test.ts

@@ -0,0 +1,272 @@
+import { NodeFileSystem } from "@effect/platform-node"
+import { describe, expect } from "bun:test"
+import { Effect, Layer } from "effect"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { Format } from "../../src/format"
+import * as Formatter from "../../src/format/formatter"
+
+const it = testEffect(Layer.mergeAll(Format.defaultLayer, CrossSpawnSpawner.defaultLayer, NodeFileSystem.layer))
+
+describe("Format", () => {
+  it.live("status() returns empty list when no formatters are configured", () =>
+    provideTmpdirInstance(() =>
+      Format.Service.use((fmt) =>
+        Effect.gen(function* () {
+          expect(yield* fmt.status()).toEqual([])
+        }),
+      ),
+    ),
+  )
+
+  it.live("status() returns built-in formatters when formatter is true", () =>
+    provideTmpdirInstance(
+      () =>
+        Format.Service.use((fmt) =>
+          Effect.gen(function* () {
+            const statuses = yield* fmt.status()
+            const gofmt = statuses.find((item) => item.name === "gofmt")
+            expect(gofmt).toBeDefined()
+            expect(gofmt!.extensions).toContain(".go")
+          }),
+        ),
+      {
+        config: {
+          formatter: true,
+        },
+      },
+    ),
+  )
+
+  it.live("status() keeps built-in formatters when config object is provided", () =>
+    provideTmpdirInstance(
+      () =>
+        Format.Service.use((fmt) =>
+          Effect.gen(function* () {
+            const statuses = yield* fmt.status()
+            const gofmt = statuses.find((item) => item.name === "gofmt")
+            const mix = statuses.find((item) => item.name === "mix")
+            expect(gofmt).toBeDefined()
+            expect(gofmt!.extensions).toContain(".go")
+            expect(mix).toBeDefined()
+          }),
+        ),
+      {
+        config: {
+          formatter: {
+            gofmt: {},
+          },
+        },
+      },
+    ),
+  )
+
+  it.live("status() excludes formatters marked as disabled in config", () =>
+    provideTmpdirInstance(
+      () =>
+        Format.Service.use((fmt) =>
+          Effect.gen(function* () {
+            const statuses = yield* fmt.status()
+            const gofmt = statuses.find((item) => item.name === "gofmt")
+            const mix = statuses.find((item) => item.name === "mix")
+            expect(gofmt).toBeUndefined()
+            expect(mix).toBeDefined()
+          }),
+        ),
+      {
+        config: {
+          formatter: {
+            gofmt: { disabled: true },
+          },
+        },
+      },
+    ),
+  )
+
+  it.live("status() excludes uv when ruff is disabled", () =>
+    provideTmpdirInstance(
+      () =>
+        Format.Service.use((fmt) =>
+          Effect.gen(function* () {
+            const statuses = yield* fmt.status()
+            expect(statuses.find((item) => item.name === "ruff")).toBeUndefined()
+            expect(statuses.find((item) => item.name === "uv")).toBeUndefined()
+          }),
+        ),
+      {
+        config: {
+          formatter: {
+            ruff: { disabled: true },
+          },
+        },
+      },
+    ),
+  )
+
+  it.live("status() excludes ruff when uv is disabled", () =>
+    provideTmpdirInstance(
+      () =>
+        Format.Service.use((fmt) =>
+          Effect.gen(function* () {
+            const statuses = yield* fmt.status()
+            expect(statuses.find((item) => item.name === "ruff")).toBeUndefined()
+            expect(statuses.find((item) => item.name === "uv")).toBeUndefined()
+          }),
+        ),
+      {
+        config: {
+          formatter: {
+            uv: { disabled: true },
+          },
+        },
+      },
+    ),
+  )
+
+  it.live("service initializes without error", () => provideTmpdirInstance(() => Format.Service.use(() => Effect.void)))
+
+  it.live("file() returns false when no formatter runs", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        Effect.gen(function* () {
+          const file = `${dir}/test.txt`
+          yield* Effect.promise(() => Bun.write(file, "x"))
+
+          const formatted = yield* Format.Service.use((fmt) => fmt.file(file))
+          expect(formatted).toBe(false)
+        }),
+      {
+        config: {
+          formatter: false,
+        },
+      },
+    ),
+  )
+
+  it.live("status() initializes formatter state per directory", () =>
+    Effect.gen(function* () {
+      const a = yield* provideTmpdirInstance(() => Format.Service.use((fmt) => fmt.status()), {
+        config: { formatter: false },
+      })
+      const b = yield* provideTmpdirInstance(() => Format.Service.use((fmt) => fmt.status()), {
+        config: {
+          formatter: true,
+        },
+      })
+
+      expect(a).toEqual([])
+      expect(b.find((item) => item.name === "gofmt")).toBeDefined()
+    }),
+  )
+
+  it.live("runs enabled checks for matching formatters in parallel", () =>
+    provideTmpdirInstance(
+      (path) =>
+        Effect.gen(function* () {
+          const file = `${path}/test.parallel`
+          yield* Effect.promise(() => Bun.write(file, "x"))
+
+          const one = {
+            extensions: Formatter.gofmt.extensions,
+            enabled: Formatter.gofmt.enabled,
+          }
+          const two = {
+            extensions: Formatter.mix.extensions,
+            enabled: Formatter.mix.enabled,
+          }
+
+          let active = 0
+          let max = 0
+
+          yield* Effect.acquireUseRelease(
+            Effect.sync(() => {
+              Formatter.gofmt.extensions = [".parallel"]
+              Formatter.mix.extensions = [".parallel"]
+              Formatter.gofmt.enabled = async () => {
+                active++
+                max = Math.max(max, active)
+                await Bun.sleep(20)
+                active--
+                return ["sh", "-c", "true"]
+              }
+              Formatter.mix.enabled = async () => {
+                active++
+                max = Math.max(max, active)
+                await Bun.sleep(20)
+                active--
+                return ["sh", "-c", "true"]
+              }
+            }),
+            () =>
+              Format.Service.use((fmt) =>
+                Effect.gen(function* () {
+                  yield* fmt.init()
+                  yield* fmt.file(file)
+                }),
+              ),
+            () =>
+              Effect.sync(() => {
+                Formatter.gofmt.extensions = one.extensions
+                Formatter.gofmt.enabled = one.enabled
+                Formatter.mix.extensions = two.extensions
+                Formatter.mix.enabled = two.enabled
+              }),
+          )
+
+          expect(max).toBe(2)
+        }),
+      {
+        config: {
+          formatter: {
+            gofmt: {},
+            mix: {},
+          },
+        },
+      },
+    ),
+  )
+
+  it.live("runs matching formatters sequentially for the same file", () =>
+    provideTmpdirInstance(
+      (path) =>
+        Effect.gen(function* () {
+          const file = `${path}/test.seq`
+          yield* Effect.promise(() => Bun.write(file, "x"))
+
+          yield* Format.Service.use((fmt) =>
+            Effect.gen(function* () {
+              yield* fmt.init()
+              expect(yield* fmt.file(file)).toBe(true)
+            }),
+          )
+
+          expect(yield* Effect.promise(() => Bun.file(file).text())).toBe("xAB")
+        }),
+      {
+        config: {
+          formatter: {
+            first: {
+              command: [
+                "node",
+                "-e",
+                "const fs = require('fs'); const file = process.argv[1]; fs.writeFileSync(file, fs.readFileSync(file, 'utf8') + 'A')",
+                "$FILE",
+              ],
+              extensions: [".seq"],
+            },
+            second: {
+              command: [
+                "node",
+                "-e",
+                "const fs = require('fs'); const file = process.argv[1]; fs.writeFileSync(file, fs.readFileSync(file, 'utf8') + 'B')",
+                "$FILE",
+              ],
+              extensions: [".seq"],
+            },
+          },
+        },
+      },
+    ),
+  )
+})

package/test/git/git.test.ts

@@ -0,0 +1,128 @@
+import { $ } from "bun"
+import { describe, expect, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { ManagedRuntime } from "effect"
+import { Git } from "../../src/git"
+import { tmpdir } from "../fixture/fixture"
+
+const weird = process.platform === "win32" ? "space file.txt" : "tab\tfile.txt"
+
+async function withGit<T>(body: (rt: ManagedRuntime.ManagedRuntime<Git.Service, never>) => Promise<T>) {
+  const rt = ManagedRuntime.make(Git.defaultLayer)
+  try {
+    return await body(rt)
+  } finally {
+    await rt.dispose()
+  }
+}
+
+describe("Git", () => {
+  test("branch() returns current branch name", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    await withGit(async (rt) => {
+      const branch = await rt.runPromise(Git.Service.use((git) => git.branch(tmp.path)))
+      expect(branch).toBeDefined()
+      expect(typeof branch).toBe("string")
+    })
+  })
+
+  test("branch() returns undefined for non-git directories", async () => {
+    await using tmp = await tmpdir()
+
+    await withGit(async (rt) => {
+      const branch = await rt.runPromise(Git.Service.use((git) => git.branch(tmp.path)))
+      expect(branch).toBeUndefined()
+    })
+  })
+
+  test("branch() returns undefined for detached HEAD", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const hash = (await $`git rev-parse HEAD`.cwd(tmp.path).quiet().text()).trim()
+    await $`git checkout --detach ${hash}`.cwd(tmp.path).quiet()
+
+    await withGit(async (rt) => {
+      const branch = await rt.runPromise(Git.Service.use((git) => git.branch(tmp.path)))
+      expect(branch).toBeUndefined()
+    })
+  })
+
+  test("defaultBranch() uses init.defaultBranch when available", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await $`git branch -M trunk`.cwd(tmp.path).quiet()
+    await $`git config init.defaultBranch trunk`.cwd(tmp.path).quiet()
+
+    await withGit(async (rt) => {
+      const branch = await rt.runPromise(Git.Service.use((git) => git.defaultBranch(tmp.path)))
+      expect(branch?.name).toBe("trunk")
+      expect(branch?.ref).toBe("trunk")
+    })
+  })
+
+  test("status() handles special filenames", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await fs.writeFile(path.join(tmp.path, weird), "hello\n", "utf-8")
+
+    await withGit(async (rt) => {
+      const status = await rt.runPromise(Git.Service.use((git) => git.status(tmp.path)))
+      expect(status).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            file: weird,
+            status: "added",
+          }),
+        ]),
+      )
+    })
+  })
+
+  test("diff(), stats(), and mergeBase() parse tracked changes", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await $`git branch -M main`.cwd(tmp.path).quiet()
+    await fs.writeFile(path.join(tmp.path, weird), "before\n", "utf-8")
+    await $`git add .`.cwd(tmp.path).quiet()
+    await $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet()
+    await $`git checkout -b feature/test`.cwd(tmp.path).quiet()
+    await fs.writeFile(path.join(tmp.path, weird), "after\n", "utf-8")
+
+    await withGit(async (rt) => {
+      const [base, diff, stats] = await Promise.all([
+        rt.runPromise(Git.Service.use((git) => git.mergeBase(tmp.path, "main"))),
+        rt.runPromise(Git.Service.use((git) => git.diff(tmp.path, "HEAD"))),
+        rt.runPromise(Git.Service.use((git) => git.stats(tmp.path, "HEAD"))),
+      ])
+
+      expect(base).toBeTruthy()
+      expect(diff).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            file: weird,
+            status: "modified",
+          }),
+        ]),
+      )
+      expect(stats).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            file: weird,
+            additions: 1,
+            deletions: 1,
+          }),
+        ]),
+      )
+    })
+  })
+
+  test("show() returns empty text for binary blobs", async () => {
+    await using tmp = await tmpdir({ git: true })
+    await fs.writeFile(path.join(tmp.path, "bin.dat"), new Uint8Array([0, 1, 2, 3]))
+    await $`git add .`.cwd(tmp.path).quiet()
+    await $`git commit --no-gpg-sign -m "add binary"`.cwd(tmp.path).quiet()
+
+    await withGit(async (rt) => {
+      const text = await rt.runPromise(Git.Service.use((git) => git.show(tmp.path, "HEAD", "bin.dat")))
+      expect(text).toBe("")
+    })
+  })
+})

package/test/ide/ide.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test, afterEach } from "bun:test"
+import { Ide } from "../../src/ide"
+
+describe("ide", () => {
+  const original = { ...process.env }
+
+  afterEach(() => {
+    Object.keys(process.env).forEach((key) => {
+      delete process.env[key]
+    })
+    Object.assign(process.env, original)
+  })
+
+  test("should detect Visual Studio Code", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] = "/path/to/Visual Studio Code.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("Visual Studio Code")
+  })
+
+  test("should detect Visual Studio Code Insiders", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] =
+      "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("Visual Studio Code - Insiders")
+  })
+
+  test("should detect Cursor", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] = "/path/to/Cursor.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("Cursor")
+  })
+
+  test("should detect VSCodium", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] = "/path/to/VSCodium.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("VSCodium")
+  })
+
+  test("should detect Windsurf", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] = "/path/to/Windsurf.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("Windsurf")
+  })
+
+  test("should return unknown when TERM_PROGRAM is not vscode", () => {
+    process.env["TERM_PROGRAM"] = "iTerm2"
+    process.env["GIT_ASKPASS"] =
+      "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("unknown")
+  })
+
+  test("should return unknown when GIT_ASKPASS does not contain IDE name", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] = "/path/to/unknown/askpass.sh"
+
+    expect(Ide.ide()).toBe("unknown")
+  })
+
+  test("should recognize vscode-insiders SAEEOL_CALLER", () => {
+    process.env["SAEEOL_CALLER"] = "vscode-insiders"
+
+    expect(Ide.alreadyInstalled()).toBe(true)
+  })
+
+  test("should recognize vscode SAEEOL_CALLER", () => {
+    process.env["SAEEOL_CALLER"] = "vscode"
+
+    expect(Ide.alreadyInstalled()).toBe(true)
+  })
+
+  test("should return false for unknown SAEEOL_CALLER", () => {
+    process.env["SAEEOL_CALLER"] = "unknown"
+
+    expect(Ide.alreadyInstalled()).toBe(false)
+  })
+})

package/test/installation/installation.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, test } from "bun:test"
+import { Effect, Layer, Stream } from "effect"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
+import { Installation } from "../../src/installation"
+import { InstallationChannel } from "@saeeol/core/installation/version"
+
+const encoder = new TextEncoder()
+
+function mockHttpClient(handler: (request: HttpClientRequest.HttpClientRequest) => Response) {
+  const client = HttpClient.make((request) => Effect.succeed(HttpClientResponse.fromWeb(request, handler(request))))
+  return Layer.succeed(HttpClient.HttpClient, client)
+}
+
+function mockSpawner(handler: (cmd: string, args: readonly string[]) => string = () => "") {
+  const spawner = ChildProcessSpawner.make((command) => {
+    const std = ChildProcess.isStandardCommand(command) ? command : undefined
+    const output = handler(std?.command ?? "", std?.args ?? [])
+    return Effect.succeed(
+      ChildProcessSpawner.makeHandle({
+        pid: ChildProcessSpawner.ProcessId(0),
+        exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(0)),
+        isRunning: Effect.succeed(false),
+        kill: () => Effect.void,
+        stdin: { [Symbol.for("effect/Sink/TypeId")]: Symbol.for("effect/Sink/TypeId") } as any,
+        stdout: output ? Stream.make(encoder.encode(output)) : Stream.empty,
+        stderr: Stream.empty,
+        all: Stream.empty,
+        getInputFd: () => ({ [Symbol.for("effect/Sink/TypeId")]: Symbol.for("effect/Sink/TypeId") }) as any,
+        getOutputFd: () => Stream.empty,
+        unref: Effect.succeed(Effect.void),
+      }),
+    )
+  })
+  return Layer.succeed(ChildProcessSpawner.ChildProcessSpawner, spawner)
+}
+
+function jsonResponse(body: unknown) {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  })
+}
+
+function testLayer(
+  httpHandler: (request: HttpClientRequest.HttpClientRequest) => Response,
+  spawnHandler?: (cmd: string, args: readonly string[]) => string,
+) {
+  return Installation.layer.pipe(Layer.provide(mockHttpClient(httpHandler)), Layer.provide(mockSpawner(spawnHandler)))
+}
+
+describe("installation", () => {
+  describe("latest", () => {
+    test("reads release version from GitHub releases", async () => {
+      const layer = testLayer(() => jsonResponse({ tag_name: "v1.2.3" }))
+
+      const result = await Effect.runPromise(
+        Installation.Service.use((svc) => svc.latest("unknown")).pipe(Effect.provide(layer)),
+      )
+      expect(result).toBe("1.2.3")
+    })
+
+    test("strips v prefix from GitHub release tag", async () => {
+      const layer = testLayer(() => jsonResponse({ tag_name: "v4.0.0-beta.1" }))
+
+      const result = await Effect.runPromise(
+        Installation.Service.use((svc) => svc.latest("curl")).pipe(Effect.provide(layer)),
+      )
+      expect(result).toBe("4.0.0-beta.1")
+    })
+
+    test("reads npm versions via registry", async () => {
+      const calls: string[] = []
+      const layer = testLayer((request) => {
+        calls.push(request.url)
+        return jsonResponse({ version: "1.5.0" })
+      })
+
+      const result = await Effect.runPromise(
+        Installation.Service.use((svc) => svc.latest("npm")).pipe(Effect.provide(layer)),
+      )
+      expect(result).toBe("1.5.0")
+      expect(calls).toContain(`https://registry.npmjs.org/@saeeol%2Fcli/${InstallationChannel}`) 
+    })
+
+    test("reads bun versions via registry", async () => {
+      const calls: string[] = []
+      const layer = testLayer((request) => {
+        calls.push(request.url)
+        return jsonResponse({ version: "1.6.0" })
+      })
+
+      const result = await Effect.runPromise(
+        Installation.Service.use((svc) => svc.latest("bun")).pipe(Effect.provide(layer)),
+      )
+      expect(result).toBe("1.6.0")
+      expect(calls).toContain(`https://registry.npmjs.org/@saeeol%2Fcli/${InstallationChannel}`) 
+    })
+
+    test("reads pnpm versions via registry", async () => {
+      const calls: string[] = []
+      const layer = testLayer((request) => {
+        calls.push(request.url)
+        return jsonResponse({ version: "1.7.0" })
+      })
+
+      const result = await Effect.runPromise(
+        Installation.Service.use((svc) => svc.latest("pnpm")).pipe(Effect.provide(layer)),
+      )
+      expect(result).toBe("1.7.0")
+      expect(calls).toContain(`https://registry.npmjs.org/@saeeol%2Fcli/${InstallationChannel}`) 
+    })
+
+    test("reads scoop manifest versions", async () => {
+      const layer = testLayer(() => jsonResponse({ version: "2.3.4" }))
+
+      const result = await Effect.runPromise(
+        Installation.Service.use((svc) => svc.latest("scoop")).pipe(Effect.provide(layer)),
+      )
+      expect(result).toBe("2.3.4")
+    })
+
+    test("reads chocolatey feed versions", async () => {
+      const layer = testLayer(() => jsonResponse({ d: { results: [{ Version: "3.4.5" }] } }))
+
+      const result = await Effect.runPromise(
+        Installation.Service.use((svc) => svc.latest("choco")).pipe(Effect.provide(layer)),
+      )
+      expect(result).toBe("3.4.5")
+    })
+
+    test("reads brew formulae API versions", async () => {
+      const layer = testLayer(
+        () => jsonResponse({ versions: { stable: "2.0.0" } }),
+        (cmd, args) => {
+          // getBrewFormula: return core formula (no tap)
+          if (cmd === "brew" && args.includes("--formula") && args.includes("SAEEOL/tap/saeeol")) return ""
+          if (cmd === "brew" && args.includes("--formula") && args.includes("saeeol")) return "saeeol"
+          return ""
+        },
+      )
+
+      const result = await Effect.runPromise(
+        Installation.Service.use((svc) => svc.latest("brew")).pipe(Effect.provide(layer)),
+      )
+      expect(result).toBe("2.0.0")
+    })
+
+    test("reads brew tap info JSON via CLI", async () => {
+      const brewInfoJson = JSON.stringify({
+        formulae: [{ versions: { stable: "2.1.0" } }],
+      })
+      const layer = testLayer(
+        () => jsonResponse({}), // HTTP not used for tap formula
+        (cmd, args) => {
+          if (cmd === "brew" && args.includes("SAEEOL/tap/saeeol") && args.includes("--formula")) return "saeeol"
+          if (cmd === "brew" && args.includes("--json=v2")) return brewInfoJson
+          return ""
+        },
+      )
+
+      const result = await Effect.runPromise(
+        Installation.Service.use((svc) => svc.latest("brew")).pipe(Effect.provide(layer)),
+      )
+      expect(result).toBe("2.1.0")
+    })
+  })
+})