saeeol 1.2.4 → 1.2.7

package/test/saeeol/compaction-skip-guard.test.ts

@@ -1,224 +0,0 @@
-// Integration test: verifies the "skip compaction when content is too small" guard
-// works end-to-end through the real compaction pipeline.
-
-import { afterEach, describe, expect, mock, test } from "bun:test"
-import { Effect, Layer, ManagedRuntime } from "effect"
-import * as Stream from "effect/Stream"
-import { Agent } from "../../src/agent/agent"
-import { Bus } from "../../src/bus"
-import { Config } from "../../src/config/config"
-import { Permission } from "../../src/permission"
-import { Plugin } from "../../src/plugin"
-import { Instance } from "../../src/project/instance"
-import { ModelID, ProviderID } from "../../src/provider/schema"
-import { Snapshot } from "../../src/snapshot"
-import { LLM } from "../../src/session/llm"
-import { MessageV2 } from "../../src/session/message-v2"
-import { SessionCompaction } from "../../src/session/compaction"
-import * as SessionProcessorModule from "../../src/session/processor"
-import { MessageID, PartID, SessionID } from "../../src/session/schema"
-import { Session as SessionNs } from "../../src/session/session"
-import { SessionStatus } from "../../src/session/status"
-import { SessionSummary } from "../../src/session/summary"
-import { ProviderTest } from "../fake/provider"
-import { tmpdir } from "../fixture/fixture"
-
-const providerID = ProviderID.make("test")
-const modelID = ModelID.make("test-model")
-const ref = { providerID, modelID }
-
-function run<A, E>(fx: Effect.Effect<A, E, SessionNs.Service>) {
-  return Effect.runPromise(fx.pipe(Effect.provide(SessionNs.defaultLayer)))
-}
-
-const svc = {
-  create(input?: SessionNs.CreateInput) {
-    return run(SessionNs.Service.use((s) => s.create(input)))
-  },
-  messages(input: Parameters<SessionNs.Interface["messages"]>[0]) {
-    return run(SessionNs.Service.use((s) => s.messages(input)))
-  },
-  updateMessage<T extends MessageV2.Info>(msg: T) {
-    return run(SessionNs.Service.use((s) => s.updateMessage(msg)))
-  },
-  updatePart<T extends MessageV2.Part>(part: T) {
-    return run(SessionNs.Service.use((s) => s.updatePart(part)))
-  },
-}
-
-const summary = Layer.succeed(
-  SessionSummary.Service,
-  SessionSummary.Service.of({
-    summarize: () => Effect.void,
-    diff: () => Effect.succeed([]),
-    computeDiff: () => Effect.succeed([]),
-  }),
-)
-
-async function user(sessionID: SessionID, text: string) {
-  const msg = await svc.updateMessage({
-    id: MessageID.ascending(),
-    role: "user",
-    sessionID,
-    agent: "build",
-    model: ref,
-    time: { created: Date.now() },
-  })
-  await svc.updatePart({
-    id: PartID.ascending(),
-    messageID: msg.id,
-    sessionID,
-    type: "text",
-    text,
-  })
-  return msg
-}
-
-async function assistant(sessionID: SessionID, parentID: MessageID, root: string, text: string) {
-  const msg: MessageV2.Assistant = {
-    id: MessageID.ascending(),
-    role: "assistant",
-    sessionID,
-    mode: "build",
-    agent: "build",
-    path: { cwd: root, root },
-    cost: 0,
-    tokens: { output: 0, input: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-    modelID,
-    providerID,
-    parentID,
-    time: { created: Date.now() },
-    finish: "stop",
-  }
-  await svc.updateMessage(msg)
-  await svc.updatePart({
-    id: PartID.ascending(),
-    messageID: msg.id,
-    sessionID,
-    type: "text",
-    text,
-  })
-  return msg
-}
-
-function llmLayer() {
-  return Layer.succeed(
-    LLM.Service,
-    LLM.Service.of({
-      stream: () => Stream.empty,
-      raw: () => Effect.die("raw not implemented"),
-    }),
-  )
-}
-
-function rt() {
-  const bus = Bus.layer
-  const status = SessionStatus.layer.pipe(Layer.provide(bus))
-  const processor = SessionProcessorModule.SessionProcessor.layer.pipe(Layer.provide(summary))
-  const model = ProviderTest.model({ providerID, id: modelID, limit: { context: 100_000, output: 32_000 } })
-  return ManagedRuntime.make(
-    Layer.mergeAll(SessionCompaction.layer.pipe(Layer.provide(processor)), processor, bus, status).pipe(
-      Layer.provide(ProviderTest.fake({ model }).layer),
-      Layer.provide(SessionNs.defaultLayer),
-      Layer.provide(Snapshot.defaultLayer),
-      Layer.provide(llmLayer()),
-      Layer.provide(Permission.defaultLayer),
-      Layer.provide(Agent.defaultLayer),
-      Layer.provide(Plugin.defaultLayer),
-      Layer.provide(status),
-      Layer.provide(bus),
-      Layer.provide(
-        Layer.mock(Config.Service)({
-          get: () =>
-            Effect.succeed({
-              ...Config.Info.zod.parse({}),
-              compaction: { reserved: 1_000, use_kg: false },
-            }),
-        }),
-      ),
-    ),
-  )
-}
-
-afterEach(() => {
-  mock.restore()
-})
-
-describe("compaction skip guard (dynamic)", () => {
-  test("skips compaction for a single short message without LLM call", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const session = await svc.create({})
-        await user(session.id, "hi")
-        await SessionCompaction.create({ sessionID: session.id, agent: "build", model: ref, auto: false })
-
-        const runtime = rt()
-        try {
-          const msgs = await svc.messages({ sessionID: session.id })
-          const parent = msgs.at(-1)?.info.id
-          expect(parent).toBeTruthy()
-
-          const result = await runtime.runPromise(
-            SessionCompaction.Service.use((s) =>
-              s.process({
-                parentID: parent!,
-                messages: msgs,
-                sessionID: session.id,
-                auto: false,
-              }),
-            ),
-          )
-
-          expect(result).toBe("continue")
-          const all = await svc.messages({ sessionID: session.id })
-          const summaries = all.filter((m) => m.info.role === "assistant" && m.info.summary)
-          expect(summaries).toHaveLength(0)
-        } finally {
-          await runtime.dispose()
-        }
-      },
-    })
-  })
-
-  test("compacts normally when there is enough content", async () => {
-    await using tmp = await tmpdir()
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const session = await svc.create({})
-        const first = await user(session.id, "first " + "a".repeat(1_000))
-        await assistant(session.id, first.id, tmp.path, "reply " + "b".repeat(1_000))
-        const second = await user(session.id, "second " + "c".repeat(1_000))
-        await assistant(session.id, second.id, tmp.path, "reply " + "d".repeat(1_000))
-        await SessionCompaction.create({ sessionID: session.id, agent: "build", model: ref, auto: false })
-
-        const runtime = rt()
-        try {
-          const msgs = await svc.messages({ sessionID: session.id })
-          const parent = msgs.at(-1)?.info.id
-          expect(parent).toBeTruthy()
-
-          const result = await runtime.runPromise(
-            SessionCompaction.Service.use((s) =>
-              s.process({
-                parentID: parent!,
-                messages: msgs,
-                sessionID: session.id,
-                auto: false,
-              }),
-            ),
-          )
-
-          expect(result).toBe("continue")
-          const all = await svc.messages({ sessionID: session.id })
-          const summaries = all.filter((m) => m.info.role === "assistant" && m.info.summary)
-          expect(summaries.length).toBeGreaterThan(0)
-        } finally {
-          await runtime.dispose()
-        }
-      },
-    })
-  })
-})

package/test/saeeol/compaction-smart-select.test.ts

@@ -1,100 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Config } from "@/config/config"
-import type { Provider } from "@/provider/provider"
-import { batchSplit, BATCH_TOKEN_TARGET, BATCH_TOKEN_MAX } from "@/saeeol/session/compaction-chunks-utils"
-import type { MessageV2 } from "@/session/message-v2"
-import { MessageID, PartID, SessionID } from "@/session/schema"
-
-function cfg(compaction?: Config.Info["compaction"]) {
-  return Config.Info.zod.parse({ compaction })
-}
-
-function msg(text: string, role: "user" | "assistant" = "user"): MessageV2.WithParts {
-  const sid = SessionID.make("test")
-  const mid = MessageID.ascending()
-  return {
-    info: {
-      id: mid,
-      role,
-      sessionID: sid,
-      time: { created: Date.now() },
-      parentID: role === "assistant" ? MessageID.ascending() : undefined,
-    } as MessageV2.Info,
-    parts: [
-      {
-        id: PartID.ascending(),
-        messageID: mid,
-        sessionID: sid,
-        type: "text",
-        text,
-      } as MessageV2.TextPart,
-    ],
-  }
-}
-
-describe("compaction select budget", () => {
-  test("preserveRecentBudget scales with model context size", () => {
-    expect(BATCH_TOKEN_TARGET).toBeGreaterThan(0)
-    expect(BATCH_TOKEN_MAX).toBeGreaterThan(BATCH_TOKEN_TARGET)
-  })
-})
-
-describe("batchSplit token-aware splitting", () => {
-  test("produces batches with head/tail/middle structure", () => {
-    const messages = Array.from({ length: 20 }, (_, i) => msg(`message ${i}`))
-    const batches = batchSplit(messages, cfg())
-    expect(batches.length).toBeGreaterThan(0)
-    for (const batch of batches) {
-      expect(batch).toHaveProperty("first")
-      expect(batch).toHaveProperty("middle")
-      expect(batch).toHaveProperty("last")
-      expect(batch).toHaveProperty("index")
-    }
-  })
-
-  test("handles empty messages", () => {
-    const batches = batchSplit([], cfg())
-    expect(batches).toEqual([])
-  })
-
-  test("handles fewer messages than batch size", () => {
-    const messages = [msg("a"), msg("b"), msg("c")]
-    const batches = batchSplit(messages, cfg())
-    expect(batches.length).toBe(1)
-    expect(batches[0].first.length + batches[0].middle.length + batches[0].last.length).toBe(3)
-  })
-
-  test("respects custom batch_size config", () => {
-    const longText = "x".repeat(2_000)
-    const messages = Array.from({ length: 30 }, (_, i) => msg(`${longText} ${i}`))
-    const batches = batchSplit(messages, cfg({ batch_size: 5 }))
-    const total = batches.reduce((s, b) => s + b.first.length + b.middle.length + b.last.length, 0)
-    expect(total).toBe(30)
-    expect(batches.length).toBeGreaterThanOrEqual(2)
-  })
-
-  test("every message appears in exactly one batch", () => {
-    const messages = Array.from({ length: 25 }, (_, i) => msg(`message ${i}`))
-    const batches = batchSplit(messages, cfg())
-    const total = batches.reduce((sum, b) => sum + b.first.length + b.middle.length + b.last.length, 0)
-    expect(total).toBe(25)
-  })
-
-  test("expands batch when messages are short (under token target)", () => {
-    const messages = Array.from({ length: 30 }, () => msg("hi"))
-    const batches = batchSplit(messages, cfg({ batch_size: 5 }))
-    expect(batches.length).toBeGreaterThan(0)
-    const firstBatch = batches[0]
-    const firstBatchTotal = firstBatch.first.length + firstBatch.middle.length + firstBatch.last.length
-    expect(firstBatchTotal).toBeGreaterThan(5)
-  })
-
-  test("shrinks batch when messages are large (over token max)", () => {
-    const longText = "x".repeat(40_000)
-    const messages = Array.from({ length: 15 }, () => msg(longText))
-    const batches = batchSplit(messages, cfg({ batch_size: 10 }))
-    const firstBatch = batches[0]
-    const firstBatchTotal = firstBatch.first.length + firstBatch.middle.length + firstBatch.last.length
-    expect(firstBatchTotal).toBeLessThanOrEqual(10)
-  })
-})

package/test/saeeol/config/config.test.ts

@@ -1,166 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect, Layer, Option } from "effect"
-import { NodeFileSystem, NodePath } from "@effect/platform-node"
-import path from "path"
-import { Global } from "@saeeol/core/global"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { EffectFlock } from "@saeeol/core/util/effect-flock"
-import * as CrossSpawnSpawner from "@saeeol/core/cross-spawn-spawner"
-import { Npm } from "@saeeol/core/npm"
-import { Account } from "../../../src/account/account"
-import { Auth } from "../../../src/auth"
-import { Config } from "../../../src/config/config"
-import { ConfigMarkdown } from "../../../src/config/markdown"
-import { Env } from "../../../src/env"
-import { SaeeolIndexing } from "../../../src/overlay/indexing"
-import { Instance } from "../../../src/project/instance"
-import { Filesystem } from "../../../src/util/filesystem"
-import { disposeAllInstances, tmpdir } from "../../fixture/fixture"
-
-const infra = CrossSpawnSpawner.defaultLayer.pipe(
-  Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)),
-)
-const emptyAccount = Layer.mock(Account.Service)({
-  active: () => Effect.succeed(Option.none()),
-  activeOrg: () => Effect.succeed(Option.none()),
-})
-const emptyAuth = Layer.mock(Auth.Service)({
-  all: () => Effect.succeed({}),
-})
-const noopNpm = Layer.mock(Npm.Service)({
-  install: () => Effect.void,
-  add: () => Effect.die("not implemented"),
-  which: () => Effect.succeed(Option.none()),
-})
-const layer = Config.layer.pipe(
-  Layer.provide(EffectFlock.defaultLayer),
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(Env.defaultLayer),
-  Layer.provide(emptyAuth),
-  Layer.provide(emptyAccount),
-  Layer.provideMerge(infra),
-  Layer.provide(noopNpm),
-)
-
-const load = () => Effect.runPromise(Config.Service.use((svc) => svc.get()).pipe(Effect.scoped, Effect.provide(layer)))
-const clear = (wait = false) =>
-  Effect.runPromise(Config.Service.use((svc) => svc.invalidate(wait)).pipe(Effect.scoped, Effect.provide(layer)))
-
-async function writeConfig(dir: string, config: object, name = "saeeol.json") {
-  await Filesystem.write(path.join(dir, name), JSON.stringify(config))
-}
-
-const cfg: Partial<Config.Info> = {
-  plugin: ["@saeeol/indexing"],
-  experimental: {
-    semantic_indexing: true,
-  },
-  indexing: {
-    provider: "ollama",
-    vectorStore: "qdrant",
-    ollama: {
-      baseUrl: "http://127.0.0.1:1",
-    },
-  },
-}
-
-afterEach(async () => {
-  delete process.env.SAEEOL_MD_TEST
-  await disposeAllInstances()
-  await clear(true)
-})
-
-describe("markdown substitutions", () => {
-  test("applies file and env substitutions to parsed markdown body", async () => {
-    process.env.SAEEOL_MD_TEST = "env content"
-    await using tmp = await tmpdir({
-      init: async (dir) => {
-        await Filesystem.write(path.join(dir, "body.md"), "file content")
-        await Filesystem.write(
-          path.join(dir, "SKILL.md"),
-          ["---", "name: test", "description: Test", "---", "{file:body.md}", "{env:SAEEOL_MD_TEST}"].join("\n"),
-        )
-      },
-    })
-
-    const md = await ConfigMarkdown.parse(path.join(tmp.path, "SKILL.md"))
-
-    expect(md.content).toContain("file content")
-    expect(md.content).toContain("env content")
-  })
-})
-
-describe("saeeol indexing config", () => {
-  test("keeps global indexing enabled in global config", async () => {
-    await using globalTmp = await tmpdir()
-    await using tmp = await tmpdir()
-
-    const prev = Global.Path.config
-    ;(Global.Path as { config: string }).config = globalTmp.path
-    await clear(true)
-
-    try {
-      await writeConfig(globalTmp.path, {
-        $schema: "https://app.saeeol.ai/config.json",
-        indexing: {
-          enabled: true,
-          provider: "ollama",
-        },
-      })
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const config = await load()
-          const global = await Effect.runPromise(
-            Config.Service.use((svc) => svc.getGlobal()).pipe(Effect.scoped, Effect.provide(layer)),
-          )
-          expect(config.indexing?.provider).toBe("ollama")
-          expect(config.indexing?.enabled).toBeUndefined()
-          expect(global.indexing?.enabled).toBe(true)
-        },
-      })
-    } finally {
-      ;(Global.Path as { config: string }).config = prev
-      await clear(true)
-    }
-  })
-
-  test("uses global indexing enabled when project enablement is unset", async () => {
-    await using globalTmp = await tmpdir()
-    await using tmp = await tmpdir({ git: true, config: cfg })
-
-    const prev = Global.Path.config
-    ;(Global.Path as { config: string }).config = globalTmp.path
-    await clear(true)
-
-    try {
-      await writeConfig(globalTmp.path, {
-        $schema: "https://app.saeeol.ai/config.json",
-        indexing: {
-          enabled: true,
-        },
-      })
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const global = await Effect.runPromise(
-            Config.Service.use((svc) => svc.getGlobal()).pipe(Effect.scoped, Effect.provide(layer)),
-          )
-          const config = await load()
-          const input = SaeeolIndexing.input(config.indexing, global.indexing)
-          expect(input.enabled).toBe(true)
-        },
-      })
-    } finally {
-      ;(Global.Path as { config: string }).config = prev
-      await clear(true)
-    }
-  })
-
-  test("global indexing enabled applies when project indexing is disabled", async () => {
-    const input = SaeeolIndexing.input({ enabled: false }, { enabled: true })
-    expect(input.enabled).toBe(true)
-  })
-})

package/test/saeeol/config/indexing-default-plugin.test.ts

@@ -1,82 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect, Layer, Option } from "effect"
-import { NodeFileSystem, NodePath } from "@effect/platform-node"
-import path from "path"
-import { hasIndexingPlugin } from "@saeeol/indexing/detect"
-import { Account } from "../../../src/account/account"
-import { Auth } from "../../../src/auth"
-import { Config } from "../../../src/config/config"
-import * as CrossSpawnSpawner from "@saeeol/core/cross-spawn-spawner"
-import { Env } from "../../../src/env"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { EffectFlock } from "@saeeol/core/util/effect-flock"
-import { Filesystem } from "../../../src/util/filesystem"
-import { Instance } from "../../../src/project/instance"
-import { Npm } from "@saeeol/core/npm"
-import { disposeAllInstances, tmpdir } from "../../fixture/fixture"
-
-const infra = CrossSpawnSpawner.defaultLayer.pipe(
-  Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)),
-)
-const emptyAccount = Layer.mock(Account.Service)({
-  active: () => Effect.succeed(Option.none()),
-  activeOrg: () => Effect.succeed(Option.none()),
-})
-const emptyAuth = Layer.mock(Auth.Service)({
-  all: () => Effect.succeed({}),
-})
-const noopNpm = Layer.mock(Npm.Service)({
-  install: () => Effect.void,
-  add: () => Effect.die("not implemented"),
-  which: () => Effect.succeed(Option.none()),
-})
-const layer = Config.layer.pipe(
-  Layer.provide(EffectFlock.defaultLayer),
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(Env.defaultLayer),
-  Layer.provide(emptyAuth),
-  Layer.provide(emptyAccount),
-  Layer.provideMerge(infra),
-  Layer.provide(noopNpm),
-)
-
-const load = () => Effect.runPromise(Config.Service.use((svc) => svc.get()).pipe(Effect.scoped, Effect.provide(layer)))
-const clear = (wait = false) =>
-  Effect.runPromise(Config.Service.use((svc) => svc.invalidate(wait)).pipe(Effect.scoped, Effect.provide(layer)))
-
-describe("saeeol default indexing plugin", () => {
-  afterEach(async () => {
-    await disposeAllInstances()
-    await clear(true)
-  })
-
-  test("does not hard-enable indexing plugin when default plugins are disabled", async () => {
-    const prev = process.env["SAEEOL_DISABLE_DEFAULT_PLUGINS"]
-    process.env["SAEEOL_DISABLE_DEFAULT_PLUGINS"] = "true"
-
-    try {
-      await using tmp = await tmpdir({
-        init: async (dir) => {
-          await Filesystem.write(
-            path.join(dir, "saeeol.json"),
-            JSON.stringify({
-              $schema: "https://app.saeeol.ai/config.json",
-              plugin: ["global-plugin-1"],
-            }),
-          )
-        },
-      })
-
-      await Instance.provide({
-        directory: tmp.path,
-        fn: async () => {
-          const config = await load()
-          expect(hasIndexingPlugin(config.plugin ?? [])).toBe(false)
-        },
-      })
-    } finally {
-      if (prev === undefined) delete process.env["SAEEOL_DISABLE_DEFAULT_PLUGINS"]
-      else process.env["SAEEOL_DISABLE_DEFAULT_PLUGINS"] = prev
-    }
-  })
-})

package/test/saeeol/config/opentelemetry-default.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Config } from "../../../src/config/config"
-
-describe("Config.Info experimental.openTelemetry default", () => {
-  test("defaults to true when experimental is set without openTelemetry", () => {
-    const parsed = Config.Info.zod.parse({ experimental: {} })
-    expect(parsed.experimental?.openTelemetry).toBe(true)
-  })
-
-  test("defaults to true when openTelemetry is explicitly undefined", () => {
-    const parsed = Config.Info.zod.parse({ experimental: { openTelemetry: undefined } })
-    expect(parsed.experimental?.openTelemetry).toBe(true)
-  })
-
-  test("respects explicit false", () => {
-    const parsed = Config.Info.zod.parse({ experimental: { openTelemetry: false } })
-    expect(parsed.experimental?.openTelemetry).toBe(false)
-  })
-
-  test("respects explicit true", () => {
-    const parsed = Config.Info.zod.parse({ experimental: { openTelemetry: true } })
-    expect(parsed.experimental?.openTelemetry).toBe(true)
-  })
-
-  test("experimental stays undefined when not set at all", () => {
-    const parsed = Config.Info.zod.parse({})
-    expect(parsed.experimental).toBeUndefined()
-  })
-})

package/test/saeeol/config-gitignore.test.ts

@@ -1,70 +0,0 @@
-//
-// Saeeol uses Npm.Service (arborist) for dependency installation and may write
-// a .gitignore inside the .saeeol config dir. Users may have pnpm or yarn as
-// their system package manager, which can produce lockfiles in the .saeeol/
-// config directory. These must be ignored so they don't appear as untracked
-// files in the user's project.
-
-import { expect, test } from "bun:test"
-import fs from "fs/promises"
-import path from "path"
-import { Effect, Layer, Option } from "effect"
-import { NodeFileSystem, NodePath } from "@effect/platform-node"
-import { Config } from "../../src/config/config"
-import { EffectFlock } from "@saeeol/core/util/effect-flock"
-import { Npm } from "@saeeol/core/npm"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { Env } from "../../src/env"
-import { Auth } from "../../src/auth"
-import { Account } from "../../src/account/account"
-import { Instance } from "../../src/project/instance"
-import { Filesystem } from "../../src/util/filesystem"
-import * as CrossSpawnSpawner from "@saeeol/core/cross-spawn-spawner"
-import { tmpdir } from "../fixture/fixture"
-
-const infra = CrossSpawnSpawner.defaultLayer.pipe(
-  Layer.provideMerge(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer)),
-)
-
-const emptyAccount = Layer.mock(Account.Service)({
-  active: () => Effect.succeed(Option.none()),
-  activeOrg: () => Effect.succeed(Option.none()),
-})
-
-const emptyAuth = Layer.mock(Auth.Service)({
-  all: () => Effect.succeed({}),
-})
-
-const noopNpm = Layer.mock(Npm.Service)({
-  install: () => Effect.void,
-  add: () => Effect.die("not implemented"),
-  which: () => Effect.succeed(Option.none()),
-})
-
-const testLayer = Config.layer.pipe(
-  Layer.provide(EffectFlock.defaultLayer),
-  Layer.provide(AppFileSystem.defaultLayer),
-  Layer.provide(Env.defaultLayer),
-  Layer.provide(emptyAuth),
-  Layer.provide(emptyAccount),
-  Layer.provideMerge(infra),
-  Layer.provide(noopNpm),
-)
-
-test(".gitignore in .saeeol config dir includes pnpm and yarn lockfile patterns", async () => {
-  await using tmp = await tmpdir()
-  const dir = path.join(tmp.path, "a")
-  const saeeol = path.join(dir, ".saeeol")
-  await fs.mkdir(saeeol, { recursive: true })
-
-  await Instance.provide({
-    directory: dir,
-    fn: async () => {
-      await Effect.runPromise(Config.Service.use((svc) => svc.get()).pipe(Effect.scoped, Effect.provide(testLayer)))
-    },
-  })
-
-  const ignore = await Filesystem.readText(path.join(saeeol, ".gitignore"))
-  expect(ignore).toContain("pnpm-lock.yaml")
-  expect(ignore).toContain("yarn.lock")
-})