saeeol 1.2.9 → 1.3.1

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

@@ -0,0 +1,224 @@
+// 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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,166 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,70 @@
+//
+// 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")
+})