@miaws/miaw 1.18.5 → 1.18.6

package/test/filesystem/filesystem.test.ts

@@ -1,319 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { NodeFileSystem } from "@effect/platform-node"
-import { FSUtil } from "@miaw/core/fs-util"
-import { testEffect } from "../lib/effect"
-import path from "path"
-
-const live = FSUtil.layer.pipe(Layer.provide(NodeFileSystem.layer))
-const { effect: it } = testEffect(live)
-
-describe("FSUtil", () => {
-  describe("isDir", () => {
-    it(
-      "returns true for directories",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        expect(yield* fs.isDir(tmp)).toBe(true)
-      }),
-    )
-
-    it(
-      "returns false for files",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        const file = path.join(tmp, "test.txt")
-        yield* fs.writeFileString(file, "hello")
-        expect(yield* fs.isDir(file)).toBe(false)
-      }),
-    )
-
-    it(
-      "returns false for non-existent paths",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        expect(yield* fs.isDir("/tmp/nonexistent-" + Math.random())).toBe(false)
-      }),
-    )
-  })
-
-  describe("isFile", () => {
-    it(
-      "returns true for files",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        const file = path.join(tmp, "test.txt")
-        yield* fs.writeFileString(file, "hello")
-        expect(yield* fs.isFile(file)).toBe(true)
-      }),
-    )
-
-    it(
-      "returns false for directories",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        expect(yield* fs.isFile(tmp)).toBe(false)
-      }),
-    )
-  })
-
-  describe("readJson / writeJson", () => {
-    it(
-      "round-trips JSON data",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        const file = path.join(tmp, "data.json")
-        const data = { name: "test", count: 42, nested: { ok: true } }
-
-        yield* fs.writeJson(file, data)
-        const result = yield* fs.readJson(file)
-
-        expect(result).toEqual(data)
-      }),
-    )
-  })
-
-  describe("ensureDir", () => {
-    it(
-      "creates nested directories",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        const nested = path.join(tmp, "a", "b", "c")
-
-        yield* fs.ensureDir(nested)
-
-        const info = yield* fs.stat(nested)
-        expect(info.type).toBe("Directory")
-      }),
-    )
-
-    it(
-      "is idempotent",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        const dir = path.join(tmp, "existing")
-        yield* fs.makeDirectory(dir)
-
-        yield* fs.ensureDir(dir)
-
-        const info = yield* fs.stat(dir)
-        expect(info.type).toBe("Directory")
-      }),
-    )
-  })
-
-  describe("writeWithDirs", () => {
-    it(
-      "creates parent directories if missing",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        const file = path.join(tmp, "deep", "nested", "file.txt")
-
-        yield* fs.writeWithDirs(file, "hello")
-
-        expect(yield* fs.readFileString(file)).toBe("hello")
-      }),
-    )
-
-    it(
-      "writes directly when parent exists",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        const file = path.join(tmp, "direct.txt")
-
-        yield* fs.writeWithDirs(file, "world")
-
-        expect(yield* fs.readFileString(file)).toBe("world")
-      }),
-    )
-
-    it(
-      "writes Uint8Array content",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        const file = path.join(tmp, "binary.bin")
-        const content = new Uint8Array([0x00, 0x01, 0x02, 0x03])
-
-        yield* fs.writeWithDirs(file, content)
-
-        const result = yield* fs.readFile(file)
-        expect(new Uint8Array(result)).toEqual(content)
-      }),
-    )
-  })
-
-  describe("findUp", () => {
-    it(
-      "finds target in start directory",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        yield* fs.writeFileString(path.join(tmp, "target.txt"), "found")
-
-        const result = yield* fs.findUp("target.txt", tmp)
-        expect(result).toEqual([path.join(tmp, "target.txt")])
-      }),
-    )
-
-    it(
-      "finds target in parent directories",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        yield* fs.writeFileString(path.join(tmp, "marker"), "root")
-        const child = path.join(tmp, "a", "b")
-        yield* fs.makeDirectory(child, { recursive: true })
-
-        const result = yield* fs.findUp("marker", child, tmp)
-        expect(result).toEqual([path.join(tmp, "marker")])
-      }),
-    )
-
-    it(
-      "returns empty array when not found",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        const result = yield* fs.findUp("nonexistent", tmp, tmp)
-        expect(result).toEqual([])
-      }),
-    )
-  })
-
-  describe("up", () => {
-    it(
-      "finds multiple targets walking up",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        yield* fs.writeFileString(path.join(tmp, "a.txt"), "a")
-        yield* fs.writeFileString(path.join(tmp, "b.txt"), "b")
-        const child = path.join(tmp, "sub")
-        yield* fs.makeDirectory(child)
-        yield* fs.writeFileString(path.join(child, "a.txt"), "a-child")
-
-        const result = yield* fs.up({ targets: ["a.txt", "b.txt"], start: child, stop: tmp })
-
-        expect(result).toContain(path.join(child, "a.txt"))
-        expect(result).toContain(path.join(tmp, "a.txt"))
-        expect(result).toContain(path.join(tmp, "b.txt"))
-      }),
-    )
-  })
-
-  describe("glob", () => {
-    it(
-      "finds files matching pattern",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        yield* fs.writeFileString(path.join(tmp, "a.ts"), "a")
-        yield* fs.writeFileString(path.join(tmp, "b.ts"), "b")
-        yield* fs.writeFileString(path.join(tmp, "c.json"), "c")
-
-        const result = yield* fs.glob("*.ts", { cwd: tmp })
-        expect(result.sort()).toEqual(["a.ts", "b.ts"])
-      }),
-    )
-
-    it(
-      "supports absolute paths",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        yield* fs.writeFileString(path.join(tmp, "file.txt"), "hello")
-
-        const result = yield* fs.glob("*.txt", { cwd: tmp, absolute: true })
-        expect(result).toEqual([path.join(tmp, "file.txt")])
-      }),
-    )
-  })
-
-  describe("globMatch", () => {
-    it(
-      "matches patterns",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        expect(fs.globMatch("*.ts", "foo.ts")).toBe(true)
-        expect(fs.globMatch("*.ts", "foo.json")).toBe(false)
-        expect(fs.globMatch("src/**", "src/a/b.ts")).toBe(true)
-      }),
-    )
-  })
-
-  describe("globUp", () => {
-    it(
-      "finds files walking up directories",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        yield* fs.writeFileString(path.join(tmp, "root.md"), "root")
-        const child = path.join(tmp, "a", "b")
-        yield* fs.makeDirectory(child, { recursive: true })
-        yield* fs.writeFileString(path.join(child, "leaf.md"), "leaf")
-
-        const result = yield* fs.globUp("*.md", child, tmp)
-        expect(result).toContain(path.join(child, "leaf.md"))
-        expect(result).toContain(path.join(tmp, "root.md"))
-      }),
-    )
-  })
-
-  describe("built-in passthrough", () => {
-    it(
-      "exists works",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        const file = path.join(tmp, "exists.txt")
-        yield* fs.writeFileString(file, "yes")
-
-        expect(yield* fs.exists(file)).toBe(true)
-        expect(yield* fs.exists(file + ".nope")).toBe(false)
-      }),
-    )
-
-    it(
-      "remove works",
-      Effect.gen(function* () {
-        const fs = yield* FSUtil.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        const file = path.join(tmp, "delete-me.txt")
-        yield* fs.writeFileString(file, "bye")
-
-        yield* fs.remove(file)
-
-        expect(yield* fs.exists(file)).toBe(false)
-      }),
-    )
-  })
-
-  describe("pure helpers", () => {
-    test("mimeType returns correct types", () => {
-      expect(FSUtil.mimeType("file.json")).toBe("application/json")
-      expect(FSUtil.mimeType("image.png")).toBe("image/png")
-      expect(FSUtil.mimeType("unknown.qzx")).toBe("application/octet-stream")
-    })
-
-    test("contains checks path containment", () => {
-      expect(FSUtil.contains("/a/b", "/a/b/c")).toBe(true)
-      expect(FSUtil.contains("/a/b", "/a/c")).toBe(false)
-    })
-
-    test("overlaps detects overlapping paths", () => {
-      expect(FSUtil.overlaps("/a/b", "/a/b/c")).toBe(true)
-      expect(FSUtil.overlaps("/a/b/c", "/a/b")).toBe(true)
-      expect(FSUtil.overlaps("/a", "/b")).toBe(false)
-    })
-  })
-})

package/test/fixture/agent-plugin.constants.ts

@@ -1,6 +0,0 @@
-// Separate file because every export in `agent-plugin.ts` must be a function.
-export const PLUGIN_AGENT = {
-  name: "plugin_added",
-  description: "Added by a plugin via the config hook",
-  mode: "subagent",
-} as const

package/test/fixture/agent-plugin.ts

@@ -1,12 +0,0 @@
-// Every export in this file must be a plugin function — `getLegacyPlugins`
-// (src/plugin/index.ts) throws on anything else. Test constants live in
-// `agent-plugin.constants.ts`.
-export default async () => ({
-  config: async (cfg: { agent?: Record<string, unknown> }) => {
-    cfg.agent = cfg.agent ?? {}
-    cfg.agent["plugin_added"] = {
-      description: "Added by a plugin via the config hook",
-      mode: "subagent",
-    }
-  },
-})

package/test/fixture/config.ts

@@ -1,23 +0,0 @@
-import { Config } from "@/config/config"
-import { emptyConsoleState } from "@miaw/core/v1/config/console-state"
-import { Effect, Layer } from "effect"
-
-export function make(overrides: Partial<Config.Interface> = {}) {
-  return Config.Service.of({
-    get: () => Effect.succeed({}),
-    getGlobal: () => Effect.succeed({}),
-    getConsoleState: () => Effect.succeed(emptyConsoleState),
-    update: () => Effect.void,
-    updateGlobal: (config) => Effect.succeed({ info: config, changed: false }),
-    invalidate: () => Effect.void,
-    directories: () => Effect.succeed([]),
-    waitForDependencies: () => Effect.void,
-    ...overrides,
-  })
-}
-
-export function layer(overrides?: Partial<Config.Interface>) {
-  return Layer.succeed(Config.Service, make(overrides))
-}
-
-export * as TestConfig from "./config"

package/test/fixture/db.ts

@@ -1,11 +0,0 @@
-import { rm } from "fs/promises"
-import { Database } from "@miaw/core/database/database"
-import { disposeAllInstances } from "./fixture"
-
-export async function resetDatabase() {
-  await disposeAllInstances().catch(() => undefined)
-  const dbPath = Database.path()
-  await rm(dbPath, { force: true }).catch(() => undefined)
-  await rm(`${dbPath}-wal`, { force: true }).catch(() => undefined)
-  await rm(`${dbPath}-shm`, { force: true }).catch(() => undefined)
-}

package/test/fixture/fixture.test.ts

@@ -1,26 +0,0 @@
-import { $ } from "bun"
-import { describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import { tmpdir } from "./fixture"
-
-describe("tmpdir", () => {
-  test("disables fsmonitor for git fixtures", async () => {
-    await using tmp = await tmpdir({ git: true })
-
-    const value = (await $`git config core.fsmonitor`.cwd(tmp.path).quiet().text()).trim()
-    expect(value).toBe("false")
-  })
-
-  test("removes directories on dispose", async () => {
-    const tmp = await tmpdir({ git: true })
-    const dir = tmp.path
-
-    await tmp[Symbol.asyncDispose]()
-
-    const exists = await fs
-      .stat(dir)
-      .then(() => true)
-      .catch(() => false)
-    expect(exists).toBe(false)
-  })
-})

package/test/fixture/fixture.ts

@@ -1,224 +0,0 @@
-import { $ } from "bun"
-import { ConfigV1 } from "@miaw/core/v1/config/config"
-import * as fs from "fs/promises"
-import os from "os"
-import path from "path"
-import { Effect, Context, Layer } from "effect"
-import type * as PlatformError from "effect/PlatformError"
-import type * as Scope from "effect/Scope"
-import { CrossSpawnSpawner } from "@miaw/core/cross-spawn-spawner"
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
-import type { Config } from "@/config/config"
-import { InstanceRef } from "../../src/effect/instance-ref"
-import { InstanceBootstrap } from "../../src/project/bootstrap-service"
-import type { InstanceContext } from "../../src/project/instance-context"
-import { InstanceRuntime } from "../../src/project/instance-runtime"
-import { InstanceStore } from "../../src/project/instance-store"
-import { TestLLMServer } from "../lib/llm-server"
-
-const noopBootstrap = Layer.succeed(InstanceBootstrap.Service, InstanceBootstrap.Service.of({ run: Effect.void }))
-export const testInstanceStoreLayer = InstanceStore.defaultLayer.pipe(Layer.provide(noopBootstrap))
-
-export async function provideTestInstance<R>(input: {
-  directory: string
-  init?: Effect.Effect<void>
-  fn: (ctx: InstanceContext) => R
-}) {
-  const ctx = await InstanceRuntime.load({ directory: input.directory })
-  try {
-    if (input.init) await Effect.runPromise(input.init.pipe(Effect.provideService(InstanceRef, ctx)))
-    return await input.fn(ctx)
-  } finally {
-    await InstanceRuntime.disposeInstance(ctx)
-  }
-}
-
-export async function withTestInstance<R>(input: { directory: string; fn: (ctx: InstanceContext) => R }) {
-  return input.fn(await InstanceRuntime.load({ directory: input.directory }))
-}
-
-export async function reloadTestInstance(input: { directory: string }) {
-  return InstanceRuntime.reloadInstance(input)
-}
-
-export async function disposeAllInstances() {
-  await InstanceRuntime.disposeAllInstances()
-}
-
-// Strip null bytes from paths (defensive fix for CI environment issues)
-function sanitizePath(p: string): string {
-  return p.replace(/\0/g, "")
-}
-
-function exists(dir: string) {
-  return fs
-    .stat(dir)
-    .then(() => true)
-    .catch(() => false)
-}
-
-function clean(dir: string) {
-  return fs.rm(dir, {
-    recursive: true,
-    force: true,
-    maxRetries: 5,
-    retryDelay: 100,
-  })
-}
-
-async function stop(dir: string) {
-  if (!(await exists(dir))) return
-  await $`git fsmonitor--daemon stop`.cwd(dir).quiet().nothrow()
-}
-
-type TmpDirOptions<T> = {
-  git?: boolean
-  config?: Partial<ConfigV1.Info>
-  init?: (dir: string) => Promise<T>
-  dispose?: (dir: string) => Promise<T>
-}
-export async function tmpdir<T>(options?: TmpDirOptions<T>) {
-  const dirpath = sanitizePath(path.join(os.tmpdir(), "miaw-test-" + Math.random().toString(36).slice(2)))
-  await fs.mkdir(dirpath, { recursive: true })
-  if (options?.git) {
-    await $`git init`.cwd(dirpath).quiet()
-    await $`git config core.fsmonitor false`.cwd(dirpath).quiet()
-    await $`git config commit.gpgsign false`.cwd(dirpath).quiet()
-    await $`git config user.email "test@miaw.test"`.cwd(dirpath).quiet()
-    await $`git config user.name "Test"`.cwd(dirpath).quiet()
-    await $`git commit --allow-empty -m "root commit ${dirpath}"`.cwd(dirpath).quiet()
-  }
-  if (options?.config) {
-    await Bun.write(
-      path.join(dirpath, "miaw.json"),
-      JSON.stringify({
-        $schema: "https://miaw/config.json",
-        ...options.config,
-      }),
-    )
-  }
-  const realpath = sanitizePath(await fs.realpath(dirpath))
-  const extra = await options?.init?.(realpath)
-  const result = {
-    [Symbol.asyncDispose]: async () => {
-      try {
-        await options?.dispose?.(realpath)
-      } finally {
-        if (options?.git) await stop(realpath).catch(() => undefined)
-        await clean(realpath).catch(() => undefined)
-      }
-    },
-    path: realpath,
-    extra: extra as T,
-  }
-  return result
-}
-
-/** Effectful scoped tmpdir. Cleaned up when the scope closes. Make sure these stay in sync */
-export function tmpdirScoped<E = never, R = never>(options?: {
-  git?: boolean
-  config?: Partial<ConfigV1.Info> | (() => Partial<ConfigV1.Info>)
-  init?: (directory: string) => Effect.Effect<void, E, R>
-}) {
-  return Effect.gen(function* () {
-    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-    const dirpath = sanitizePath(path.join(os.tmpdir(), "miaw-test-" + Math.random().toString(36).slice(2)))
-    yield* Effect.promise(() => fs.mkdir(dirpath, { recursive: true }))
-    const dir = sanitizePath(yield* Effect.promise(() => fs.realpath(dirpath)))
-
-    yield* Effect.addFinalizer(() =>
-      Effect.promise(async () => {
-        if (options?.git) await stop(dir).catch(() => undefined)
-        await clean(dir).catch(() => undefined)
-      }),
-    )
-
-    const git = (...args: string[]) =>
-      spawner.spawn(ChildProcess.make("git", args, { cwd: dir })).pipe(Effect.flatMap((handle) => handle.exitCode))
-
-    if (options?.git) {
-      yield* git("init")
-      yield* git("config", "core.fsmonitor", "false")
-      yield* git("config", "commit.gpgsign", "false")
-      yield* git("config", "user.email", "test@miaw.test")
-      yield* git("config", "user.name", "Test")
-      yield* git("commit", "--allow-empty", "-m", `root commit ${dir}`)
-    }
-
-    if (options?.config) {
-      const resolved = typeof options.config === "function" ? options.config() : options.config
-      yield* Effect.promise(() =>
-        fs.writeFile(
-          path.join(dir, "miaw.json"),
-          JSON.stringify({ $schema: "https://miaw/config.json", ...resolved }),
-        ),
-      )
-    }
-
-    if (options?.init) yield* options.init(dir)
-
-    return dir
-  })
-}
-
-export const provideInstance =
-  (directory: string) =>
-  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | InstanceStore.Service> =>
-    InstanceStore.Service.use((store) => store.provide({ directory }, self))
-
-export const provideInstanceEffect =
-  (directory: string) =>
-  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | InstanceStore.Service> =>
-    InstanceStore.Service.use((store) => store.provide({ directory }, self))
-
-export const reloadInstance = (input: InstanceStore.LoadInput) =>
-  InstanceStore.Service.use((store) => store.reload(input))
-
-export const disposeAllInstancesEffect = InstanceStore.Service.use((store) => store.disposeAll())
-
-export function provideTmpdirInstance<A, E, R>(
-  self: (path: string) => Effect.Effect<A, E, R>,
-  options?: { git?: boolean; config?: Partial<ConfigV1.Info> | (() => Partial<ConfigV1.Info>) },
-) {
-  return Effect.gen(function* () {
-    const path = yield* tmpdirScoped(options)
-    return yield* self(path).pipe(provideInstance(path))
-  }).pipe(Effect.provide(testInstanceStoreLayer))
-}
-
-export class TestInstance extends Context.Service<TestInstance, { readonly directory: string }>()("@test/Instance") {}
-
-export const requireInstance = Effect.gen(function* () {
-  const instance = yield* InstanceRef
-  if (!instance) return yield* Effect.die(new Error("missing test instance"))
-  return instance
-})
-
-export const withTmpdirInstance =
-  <E2 = never, R2 = never>(options?: {
-    git?: boolean
-    config?: Partial<ConfigV1.Info> | (() => Partial<ConfigV1.Info>)
-    init?: (directory: string) => Effect.Effect<void, E2, R2>
-  }) =>
-  <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    Effect.gen(function* () {
-      const directory = yield* tmpdirScoped(options)
-      return yield* self.pipe(Effect.provideService(TestInstance, { directory }), provideInstanceEffect(directory))
-    }).pipe(Effect.provide(testInstanceStoreLayer), Effect.provide(CrossSpawnSpawner.defaultLayer))
-
-export function provideTmpdirServer<A, E, R>(
-  self: (input: { dir: string; llm: TestLLMServer["Service"] }) => Effect.Effect<A, E, R>,
-  options?: { git?: boolean; config?: (url: string) => Partial<ConfigV1.Info> },
-): Effect.Effect<
-  A,
-  E | PlatformError.PlatformError,
-  R | TestLLMServer | ChildProcessSpawner.ChildProcessSpawner | Scope.Scope
-> {
-  return Effect.gen(function* () {
-    const llm = yield* TestLLMServer
-    return yield* provideTmpdirInstance((dir) => self({ dir, llm }), {
-      git: options?.git,
-      config: options?.config?.(llm.url),
-    })
-  })
-}

package/test/fixture/flag.ts

@@ -1,20 +0,0 @@
-import type { WorkspaceV2 } from "@miaw/core/workspace"
-import { Flag } from "@miaw/core/flag/flag"
-import { Effect, Scope } from "effect"
-
-/**
- * Scoped override for `Flag.MIAW_WORKSPACE_ID`. Saves the previous value
- * on entry and restores it via finalizer when the surrounding scope closes —
- * preserves the original try/finally semantics regardless of test outcome.
- */
-export function withFixedWorkspaceID(id: WorkspaceV2.ID): Effect.Effect<void, never, Scope.Scope> {
-  return Effect.gen(function* () {
-    const previous = Flag.MIAW_WORKSPACE_ID
-    Flag.MIAW_WORKSPACE_ID = id
-    yield* Effect.addFinalizer(() =>
-      Effect.sync(() => {
-        Flag.MIAW_WORKSPACE_ID = previous
-      }),
-    )
-  })
-}