saeeol 1.2.5 → 1.2.7

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 { AppFileSystem } from "@saeeol/core/filesystem"
-import { testEffect } from "../lib/effect"
-import path from "path"
-
-const live = AppFileSystem.layer.pipe(Layer.provide(NodeFileSystem.layer))
-const { effect: it } = testEffect(live)
-
-describe("AppFileSystem", () => {
-  describe("isDir", () => {
-    it(
-      "returns true for directories",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const tmp = yield* fs.makeTempDirectoryScoped()
-        expect(yield* fs.isDir(tmp)).toBe(true)
-      }),
-    )
-
-    it(
-      "returns false for files",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.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* AppFileSystem.Service
-        expect(yield* fs.isDir("/tmp/nonexistent-" + Math.random())).toBe(false)
-      }),
-    )
-  })
-
-  describe("isFile", () => {
-    it(
-      "returns true for files",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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* AppFileSystem.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(AppFileSystem.mimeType("file.json")).toBe("application/json")
-      expect(AppFileSystem.mimeType("image.png")).toBe("image/png")
-      expect(AppFileSystem.mimeType("unknown.qzx")).toBe("application/octet-stream")
-    })
-
-    test("contains checks path containment", () => {
-      expect(AppFileSystem.contains("/a/b", "/a/b/c")).toBe(true)
-      expect(AppFileSystem.contains("/a/b", "/a/c")).toBe(false)
-    })
-
-    test("overlaps detects overlapping paths", () => {
-      expect(AppFileSystem.overlaps("/a/b", "/a/b/c")).toBe(true)
-      expect(AppFileSystem.overlaps("/a/b/c", "/a/b")).toBe(true)
-      expect(AppFileSystem.overlaps("/a", "/b")).toBe(false)
-    })
-  })
-})

package/test/fixture/db.ts

@@ -1,11 +0,0 @@
-import { rm } from "fs/promises"
-import { Database } from "@/storage/db"
-import { disposeAllInstances } from "./fixture"
-
-export async function resetDatabase() {
-  await disposeAllInstances().catch(() => undefined)
-  Database.close()
-  await rm(Database.Path, { force: true }).catch(() => undefined)
-  await rm(`${Database.Path}-wal`, { force: true }).catch(() => undefined)
-  await rm(`${Database.Path}-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,175 +0,0 @@
-import { $ } from "bun"
-import * as fs from "fs/promises"
-import os from "os"
-import path from "path"
-import { Effect, Context } from "effect"
-import type * as PlatformError from "effect/PlatformError"
-import type * as Scope from "effect/Scope"
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
-import type { Config } from "@/config/config"
-import { InstanceRef } from "../../src/effect/instance-ref"
-import { InstanceStore } from "../../src/project/instance-store"
-import { Instance } from "../../src/project/instance"
-import { TestLLMServer } from "../lib/llm-server"
-import { remove as cleanup } from "../saeeol/cleanup" 
-
-// Re-export for test ergonomics. The implementation lives next to the runtime
-// it consumes; see `InstanceStore.disposeAllInstances` for the rationale.
-export { disposeAllInstances } from "../../src/project/instance-store"
-
-// 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 cleanup(dir) 
-}
-
-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<Config.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(), "saeeol-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@saeeol.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, "saeeol.json"),
-      JSON.stringify({
-        $schema: "https://app.saeeol.ai/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(options?: { git?: boolean; config?: Partial<Config.Info> }) {
-  return Effect.gen(function* () {
-    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-    const dirpath = sanitizePath(path.join(os.tmpdir(), "saeeol-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@saeeol.test")
-      yield* git("config", "user.name", "Test")
-      yield* git("commit", "--allow-empty", "-m", "root commit")
-    }
-
-    if (options?.config) {
-      yield* Effect.promise(() =>
-        fs.writeFile(
-          path.join(dir, "saeeol.json"),
-          JSON.stringify({ $schema: "https://saeeol.ai/config.json", ...options.config }),
-        ),
-      )
-    }
-
-    return dir
-  })
-}
-
-export const provideInstance =
-  (directory: string) =>
-  <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
-    Effect.contextWith((services: Context.Context<R>) =>
-      Effect.promise<A>(async () =>
-        Instance.provide({
-          directory,
-          fn: () => Effect.runPromiseWith(services)(self.pipe(Effect.provideService(InstanceRef, Instance.current))),
-        }),
-      ),
-    )
-
-export function provideTmpdirInstance<A, E, R>(
-  self: (path: string) => Effect.Effect<A, E, R>,
-  options?: { git?: boolean; config?: Partial<Config.Info> },
-) {
-  return Effect.gen(function* () {
-    const path = yield* tmpdirScoped(options)
-    let provided = false
-
-    yield* Effect.addFinalizer(() =>
-      provided
-        ? Effect.promise(() =>
-            Instance.provide({
-              directory: path,
-              fn: () => InstanceStore.disposeInstance(Instance.current),
-            }),
-          ).pipe(Effect.ignore)
-        : Effect.void,
-    )
-
-    provided = true
-    return yield* self(path).pipe(provideInstance(path))
-  })
-}
-
-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<Config.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/flock-worker.ts

@@ -1,72 +0,0 @@
-import fs from "fs/promises"
-import { Flock } from "@saeeol/core/util/flock"
-
-type Msg = {
-  key: string
-  dir: string
-  staleMs?: number
-  timeoutMs?: number
-  baseDelayMs?: number
-  maxDelayMs?: number
-  holdMs?: number
-  ready?: string
-  active?: string
-  done?: string
-}
-
-function sleep(ms: number) {
-  return new Promise<void>((resolve) => {
-    setTimeout(resolve, ms)
-  })
-}
-
-function input() {
-  const raw = process.argv[2]
-  if (!raw) {
-    throw new Error("Missing flock worker input")
-  }
-
-  return JSON.parse(raw) as Msg
-}
-
-async function job(input: Msg) {
-  if (input.ready) {
-    await fs.writeFile(input.ready, String(process.pid))
-  }
-
-  if (input.active) {
-    await fs.writeFile(input.active, String(process.pid), { flag: "wx" })
-  }
-
-  try {
-    if (input.holdMs && input.holdMs > 0) {
-      await sleep(input.holdMs)
-    }
-
-    if (input.done) {
-      await fs.appendFile(input.done, "1\n")
-    }
-  } finally {
-    if (input.active) {
-      await fs.rm(input.active, { force: true })
-    }
-  }
-}
-
-async function main() {
-  const msg = input()
-
-  await Flock.withLock(msg.key, () => job(msg), {
-    dir: msg.dir,
-    staleMs: msg.staleMs,
-    timeoutMs: msg.timeoutMs,
-    baseDelayMs: msg.baseDelayMs,
-    maxDelayMs: msg.maxDelayMs,
-  })
-}
-
-await main().catch((err) => {
-  const text = err instanceof Error ? (err.stack ?? err.message) : String(err)
-  process.stderr.write(text)
-  process.exit(1)
-})

package/test/fixture/log-init-worker.ts

@@ -1,62 +0,0 @@
-
-import fs from "fs/promises"
-import path from "path"
-
-const dir = process.argv[2]
-const mode = process.argv[3]
-
-if (!dir) {
-  throw new Error("missing temp dir")
-}
-
-process.env.XDG_DATA_HOME = path.join(dir, "share")
-process.env.XDG_CACHE_HOME = path.join(dir, "cache")
-process.env.XDG_CONFIG_HOME = path.join(dir, "config")
-process.env.XDG_STATE_HOME = path.join(dir, "state")
-process.env.SAEEOL_TEST_HOME = path.join(dir, "home")
-
-const Log = await import("@saeeol/core/util/log")
-
-async function bytes(file: string) {
-  return fs
-    .stat(file)
-    .then((stat) => stat.size)
-    .catch(() => 0)
-}
-
-async function wait(file: string, need: number) {
-  for (let i = 0; i < 500; i++) {
-    if ((await bytes(file)) >= need) return
-    await Bun.sleep(10)
-  }
-
-  throw new Error(`log file did not reach ${need} bytes before missing-file test`)
-}
-
-await Log.init({
-  print: false,
-  dev: true,
-  level: "DEBUG",
-})
-
-const log = Log.create({ service: "test" })
-const msg = "x".repeat(1024 * 1024)
-const first = mode === "missing" ? 10 : 55
-
-await fs.mkdir(path.join(dir, "share", "saeeol", "log"), { recursive: true })
-for (const _ of Array.from({ length: first })) {
-  log.info(msg)
-}
-
-if (mode === "missing") {
-  await wait(Log.file(), first * msg.length)
-  await fs.unlink(Log.file())
-
-  for (const _ of Array.from({ length: 45 })) {
-    log.info(msg)
-  }
-}
-
-await Bun.sleep(300)
-
-process.stdout.write(Log.file())