@miaws/miaw 1.18.5 → 1.18.6

package/test/format/format.test.ts

@@ -1,228 +0,0 @@
-import { NodeFileSystem } from "@effect/platform-node"
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { provideTmpdirInstance, testInstanceStoreLayer, TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { CrossSpawnSpawner } from "@miaw/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.instance("status() returns empty list when no formatters are configured", () =>
-    Format.Service.use((fmt) =>
-      Effect.gen(function* () {
-        expect(yield* fmt.status()).toEqual([])
-      }),
-    ),
-  )
-
-  it.instance(
-    "status() returns built-in formatters when formatter is true",
-    () =>
-      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.instance(
-    "status() keeps built-in formatters when config object is provided",
-    () =>
-      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.instance(
-    "status() excludes formatters marked as disabled in config",
-    () =>
-      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.instance(
-    "status() excludes uv when ruff is disabled",
-    () =>
-      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.instance(
-    "status() excludes ruff when uv is disabled",
-    () =>
-      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.instance("service initializes without error", () => Format.Service.use(() => Effect.void))
-
-  it.instance(
-    "file() returns false when no formatter runs",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const file = `${test.directory}/test.txt`
-        yield* Effect.promise(() => Bun.write(file, "x"))
-
-        const formatted = yield* Format.use.file(file)
-        expect(formatted).toBe(false)
-      }),
-    { config: { formatter: false } },
-  )
-
-  testEffect(
-    Layer.mergeAll(Format.defaultLayer, CrossSpawnSpawner.defaultLayer, NodeFileSystem.layer, testInstanceStoreLayer),
-  ).live("status() initializes formatter state per directory", () =>
-    Effect.gen(function* () {
-      const a = yield* provideTmpdirInstance(() => Format.use.status(), {
-        config: { formatter: false },
-      })
-      const b = yield* provideTmpdirInstance(() => Format.use.status(), {
-        config: {
-          formatter: true,
-        },
-      })
-
-      expect(a).toEqual([])
-      expect(b.find((item) => item.name === "gofmt")).toBeDefined()
-    }),
-  )
-
-  it.instance(
-    "runs enabled checks for matching formatters in parallel",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const file = `${test.directory}/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 Promise.resolve()
-              active--
-              return ["sh", "-c", "true"]
-            }
-            Formatter.mix.enabled = async () => {
-              active++
-              max = Math.max(max, active)
-              await Promise.resolve()
-              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.instance(
-    "runs matching formatters sequentially for the same file",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const file = `${test.directory}/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

@@ -1,178 +0,0 @@
-import { $ } from "bun"
-import { describe, expect } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { Effect } from "effect"
-import { Git } from "../../src/git"
-import { tmpdir } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const weird = process.platform === "win32" ? "space file.txt" : "tab\tfile.txt"
-const it = testEffect(Git.defaultLayer)
-
-const scopedTmpdir = (options?: Parameters<typeof tmpdir>[0]) =>
-  Effect.acquireRelease(
-    Effect.promise(() => tmpdir(options)),
-    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  )
-
-describe("Git", () => {
-  it.live("branch() returns current branch name", () =>
-    Effect.gen(function* () {
-      const tmp = yield* scopedTmpdir({ git: true })
-      const git = yield* Git.Service
-      const branch = yield* git.branch(tmp.path)
-      expect(branch).toBeDefined()
-      expect(typeof branch).toBe("string")
-    }),
-  )
-
-  it.live("branch() returns undefined for non-git directories", () =>
-    Effect.gen(function* () {
-      const tmp = yield* scopedTmpdir()
-      const git = yield* Git.Service
-      const branch = yield* git.branch(tmp.path)
-      expect(branch).toBeUndefined()
-    }),
-  )
-
-  it.live("branch() returns undefined for detached HEAD", () =>
-    Effect.gen(function* () {
-      const tmp = yield* scopedTmpdir({ git: true })
-      const hash = (yield* Effect.promise(() => $`git rev-parse HEAD`.cwd(tmp.path).quiet().text())).trim()
-      yield* Effect.promise(() => $`git checkout --detach ${hash}`.cwd(tmp.path).quiet())
-      const git = yield* Git.Service
-      const branch = yield* git.branch(tmp.path)
-      expect(branch).toBeUndefined()
-    }),
-  )
-
-  it.live("defaultBranch() uses init.defaultBranch when available", () =>
-    Effect.gen(function* () {
-      const tmp = yield* scopedTmpdir({ git: true })
-      yield* Effect.promise(() => $`git branch -M trunk`.cwd(tmp.path).quiet())
-      yield* Effect.promise(() => $`git config init.defaultBranch trunk`.cwd(tmp.path).quiet())
-      const git = yield* Git.Service
-      const branch = yield* git.defaultBranch(tmp.path)
-      expect(branch?.name).toBe("trunk")
-      expect(branch?.ref).toBe("trunk")
-    }),
-  )
-
-  it.live("status() handles special filenames", () =>
-    Effect.gen(function* () {
-      const tmp = yield* scopedTmpdir({ git: true })
-      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "hello\n", "utf-8"))
-      const git = yield* Git.Service
-      const status = yield* git.status(tmp.path)
-      expect(status).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            file: weird,
-            status: "added",
-          }),
-        ]),
-      )
-    }),
-  )
-
-  it.live("diff(), stats(), and mergeBase() parse tracked changes", () =>
-    Effect.gen(function* () {
-      const tmp = yield* scopedTmpdir({ git: true })
-      yield* Effect.promise(() => $`git branch -M main`.cwd(tmp.path).quiet())
-      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "before\n", "utf-8"))
-      yield* Effect.promise(() => $`git add .`.cwd(tmp.path).quiet())
-      yield* Effect.promise(() => $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet())
-      yield* Effect.promise(() => $`git checkout -b feature/test`.cwd(tmp.path).quiet())
-      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "after\n", "utf-8"))
-
-      const git = yield* Git.Service
-      const [base, diff, stats] = yield* Effect.all([
-        git.mergeBase(tmp.path, "main"),
-        git.diff(tmp.path, "HEAD"),
-        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,
-          }),
-        ]),
-      )
-    }),
-  )
-
-  it.live("patch() returns capped native patch output", () =>
-    Effect.gen(function* () {
-      const tmp = yield* scopedTmpdir({ git: true })
-      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "before\n", "utf-8"))
-      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "other.txt"), "old\n", "utf-8"))
-      yield* Effect.promise(() => $`git add .`.cwd(tmp.path).quiet())
-      yield* Effect.promise(() => $`git commit --no-gpg-sign -m "add file"`.cwd(tmp.path).quiet())
-      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "after\n", "utf-8"))
-      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "other.txt"), "new\n", "utf-8"))
-
-      const git = yield* Git.Service
-      const [patch, all, capped] = yield* Effect.all([
-        git.patch(tmp.path, "HEAD", weird, { context: 2_147_483_647 }),
-        git.patchAll(tmp.path, "HEAD", { context: 2_147_483_647 }),
-        git.patch(tmp.path, "HEAD", weird, { maxOutputBytes: 1 }),
-      ])
-
-      expect(patch.truncated).toBe(false)
-      expect(patch.text).toContain("diff --git")
-      expect(patch.text).toContain("-before")
-      expect(patch.text).toContain("+after")
-      expect(all.truncated).toBe(false)
-      expect(all.text).toContain("diff --git")
-      expect(all.text).toContain("other.txt")
-      expect(all.text).toContain("+new")
-      expect(capped.truncated).toBe(true)
-      expect(capped.text).toBe("")
-    }),
-  )
-
-  it.live("patchUntracked() and statUntracked() handle added files", () =>
-    Effect.gen(function* () {
-      const tmp = yield* scopedTmpdir({ git: true })
-      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, weird), "one\ntwo\n", "utf-8"))
-
-      const git = yield* Git.Service
-      const [patch, stat] = yield* Effect.all([
-        git.patchUntracked(tmp.path, weird, { context: 2_147_483_647 }),
-        git.statUntracked(tmp.path, weird),
-      ])
-
-      expect(patch.truncated).toBe(false)
-      expect(patch.text).toContain("diff --git")
-      expect(patch.text).toContain("+one")
-      expect(patch.text).toContain("+two")
-      expect(stat).toEqual(expect.objectContaining({ file: weird, additions: 2, deletions: 0 }))
-    }),
-  )
-
-  it.live("show() returns empty text for binary blobs", () =>
-    Effect.gen(function* () {
-      const tmp = yield* scopedTmpdir({ git: true })
-      yield* Effect.promise(() => fs.writeFile(path.join(tmp.path, "bin.dat"), new Uint8Array([0, 1, 2, 3])))
-      yield* Effect.promise(() => $`git add .`.cwd(tmp.path).quiet())
-      yield* Effect.promise(() => $`git commit --no-gpg-sign -m "add binary"`.cwd(tmp.path).quiet())
-
-      const git = yield* Git.Service
-      const text = yield* git.show(tmp.path, "HEAD", "bin.dat")
-      expect(text).toBe("")
-    }),
-  )
-})

package/test/ide/ide.test.ts

@@ -1,82 +0,0 @@
-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 MIAW_CALLER", () => {
-    process.env["MIAW_CALLER"] = "vscode-insiders"
-
-    expect(Ide.alreadyInstalled()).toBe(true)
-  })
-
-  test("should recognize vscode MIAW_CALLER", () => {
-    process.env["MIAW_CALLER"] = "vscode"
-
-    expect(Ide.alreadyInstalled()).toBe(true)
-  })
-
-  test("should return false for unknown MIAW_CALLER", () => {
-    process.env["MIAW_CALLER"] = "unknown"
-
-    expect(Ide.alreadyInstalled()).toBe(false)
-  })
-})

package/test/image/image.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Cause, Effect, Exit, Layer } from "effect"
-import { Image } from "@/image/image"
-import { MessageID, PartID, SessionID } from "@/session/schema"
-import path from "node:path"
-import { TestConfig } from "../fixture/config"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(Layer.mergeAll(Image.layer.pipe(Layer.provide(TestConfig.layer()))))
-const tiny = testEffect(
-  Layer.mergeAll(
-    Image.layer.pipe(
-      Layer.provide(
-        TestConfig.layer({ get: () => Effect.succeed({ attachment: { image: { max_base64_bytes: 1 } } }) }),
-      ),
-    ),
-  ),
-)
-
-function part(mime: string, data: string) {
-  return {
-    id: PartID.ascending(),
-    messageID: MessageID.ascending(),
-    sessionID: SessionID.make("ses_test"),
-    type: "file" as const,
-    mime,
-    url: `data:${mime};base64,${data}`,
-  }
-}
-
-describe("Image", () => {
-  it.effect("normalizes generated png and jpeg attachments", () =>
-    Effect.gen(function* () {
-      const photon = yield* Effect.promise(() => import("@silvia-odwyer/photon-node"))
-      const source = new photon.PhotonImage(
-        new Uint8Array(Array.from({ length: 64 * 64 * 4 }, (_, index) => (index % 4 === 3 ? 255 : index % 251))),
-        64,
-        64,
-      )
-      const image = yield* Image.Service
-      const results = yield* Effect.all([
-        image.normalize(part("image/png", Buffer.from(source.get_bytes()).toString("base64"))),
-        image.normalize(part("image/jpeg", Buffer.from(source.get_bytes_jpeg(90)).toString("base64"))),
-      ])
-
-      source.free()
-      expect(results.map((result) => result.url.startsWith(`data:${result.mime};base64,`))).toEqual([true, true])
-      expect(results.every((result) => result.mime === "image/png" || result.mime === "image/jpeg")).toBe(true)
-    }),
-  )
-
-  it.effect("accepts webp attachments that are already within limits", () =>
-    Effect.gen(function* () {
-      const image = yield* Image.Service
-      const input = part("image/webp", "UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA")
-
-      expect(yield* image.normalize(input)).toEqual(input)
-    }),
-  )
-
-  it.effect("resizes images that fit the byte limit but exceed dimension limits", () =>
-    Effect.gen(function* () {
-      const photon = yield* Effect.promise(() => import("@silvia-odwyer/photon-node"))
-      const source = new photon.PhotonImage(new Uint8Array(Array.from({ length: 9_000 * 4 }, () => 255)), 9_000, 1)
-      const image = yield* Image.Service
-      const result = yield* image.normalize(part("image/png", Buffer.from(source.get_bytes()).toString("base64")))
-      const resized = photon.PhotonImage.new_from_byteslice(
-        Buffer.from(result.url.slice(result.url.indexOf(";base64,") + ";base64,".length), "base64"),
-      )
-
-      source.free()
-      expect(resized.get_width()).toBeLessThanOrEqual(2_000)
-      expect(resized.get_height()).toBeLessThanOrEqual(2_000)
-      resized.free()
-    }),
-  )
-
-  it.effect("resizes the 5MB base64 picture fixture", () =>
-    Effect.gen(function* () {
-      const photon = yield* Effect.promise(() => import("@silvia-odwyer/photon-node"))
-      const data = Buffer.from(
-        yield* Effect.promise(() =>
-          Bun.file(path.join(import.meta.dir, "fixtures", "picture-5mb-base64.png")).arrayBuffer(),
-        ),
-      )
-      const input = part("image/png", data.toString("base64"))
-      const image = yield* Image.Service
-      const result = yield* image.normalize(input)
-      const base64 = result.url.slice(result.url.indexOf(";base64,") + ";base64,".length)
-      const resized = photon.PhotonImage.new_from_byteslice(Buffer.from(base64, "base64"))
-
-      expect(input.url.slice(input.url.indexOf(";base64,") + ";base64,".length).length).toBe(5 * 1024 * 1024)
-      expect(result.url).not.toBe(input.url)
-      expect(base64.length).toBeLessThan(5 * 1024 * 1024)
-      expect(resized.get_width()).toBeLessThanOrEqual(2_000)
-      expect(resized.get_height()).toBeLessThanOrEqual(2_000)
-      resized.free()
-    }),
-  )
-
-  tiny.effect("fails with a typed size error when no resized candidate fits", () =>
-    Effect.gen(function* () {
-      const photon = yield* Effect.promise(() => import("@silvia-odwyer/photon-node"))
-      const source = new photon.PhotonImage(new Uint8Array(Array.from({ length: 4 }, () => 255)), 1, 1)
-      const image = yield* Image.Service
-      const exit = yield* image
-        .normalize(part("image/png", Buffer.from(source.get_bytes()).toString("base64")))
-        .pipe(Effect.exit)
-
-      source.free()
-      expect(Exit.isFailure(exit)).toBe(true)
-      if (Exit.isFailure(exit)) {
-        const error = Cause.squash(exit.cause)
-        expect(error).toBeInstanceOf(Image.SizeError)
-        if (error instanceof Image.SizeError) {
-          expect(error.width).toBe(1)
-          expect(error.height).toBe(1)
-          expect(error.max).toBe(1)
-        }
-      }
-    }),
-  )
-})