saeeol 1.3.0 → 1.4.0

package/test/saeeol/project-config-update.test.ts

@@ -0,0 +1,120 @@
+
+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 { AppFileSystem } from "@saeeol/core/filesystem"
+import { EffectFlock } from "@saeeol/core/util/effect-flock"
+import { Config } from "../../src/config/config"
+import { Auth } from "../../src/auth"
+import { Account } from "../../src/account/account"
+import { Env } from "../../src/env"
+import { Npm } from "@saeeol/core/npm"
+import { Instance } from "../../src/project/instance"
+import { Filesystem } from "../../src/util/filesystem"
+import { 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 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 save = (config: Config.Info) =>
+  Effect.runPromise(Config.Service.use((svc) => svc.update(config)).pipe(Effect.scoped, Effect.provide(layer)))
+
+async function writeConfig(dir: string, config: unknown) {
+  await Filesystem.write(path.join(dir, "saeeol.json"), JSON.stringify(config, null, 2))
+}
+
+test("project config update creates .saeeol/saeeol.json and reloads it", async () => {
+  await using tmp = await tmpdir()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      await save({ model: "updated/model" } as any)
+
+      const written = await Filesystem.readJson<{ model: string }>(path.join(tmp.path, ".saeeol", "saeeol.json"))
+      expect(written.model).toBe("updated/model")
+
+      const loaded = await load()
+      expect(loaded.model).toBe("updated/model")
+    },
+  })
+})
+
+test("project config update skips empty delete-only writes when no config exists", async () => {
+  await using tmp = await tmpdir()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      await save({ provider: { missing: null } } as any)
+
+      await expect(fs.access(path.join(tmp.path, ".saeeol", "saeeol.json"))).rejects.toThrow()
+    },
+  })
+})
+
+test("project config update prefers existing root saeeol.json", async () => {
+  await using tmp = await tmpdir()
+  await writeConfig(tmp.path, { username: "alice" })
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      await save({ model: "updated/model" } as any)
+
+      const merged = await Filesystem.readJson<{ model: string; username: string }>(path.join(tmp.path, "saeeol.json"))
+      expect(merged.model).toBe("updated/model")
+      expect(merged.username).toBe("alice")
+    },
+  })
+})
+
+test("project config update patches ancestor .saeeol/saeeol.json from nested directory", async () => {
+  await using tmp = await tmpdir()
+  const child = path.join(tmp.path, "nested", "workspace")
+  await fs.mkdir(child, { recursive: true })
+  await fs.mkdir(path.join(tmp.path, ".saeeol"), { recursive: true })
+  await writeConfig(path.join(tmp.path, ".saeeol"), { username: "alice" })
+
+  await Instance.provide({
+    directory: child,
+    fn: async () => {
+      await save({ model: "updated/model" } as any)
+
+      const merged = await Filesystem.readJson<{ model: string; username: string }>(
+        path.join(tmp.path, ".saeeol", "saeeol.json"),
+      )
+      expect(merged.model).toBe("updated/model")
+      expect(merged.username).toBe("alice")
+      await expect(fs.access(path.join(child, ".saeeol", "saeeol.json"))).rejects.toThrow()
+    },
+  })
+})

package/test/saeeol/project-id.test.ts

@@ -0,0 +1,455 @@
+import { test, expect, describe } from "bun:test"
+import { tmpdir } from "../fixture/fixture"
+import path from "path"
+import fs from "fs/promises"
+import { Instance } from "../../src/project/instance"
+import { getSaeeolProjectId } from "../../src/overlay/project-id"
+
+describe("project-id", () => {
+  describe("normalization", () => {
+    test("extracts repo name from HTTPS git URL", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          // Set git origin to HTTPS URL
+          await Bun.$`git remote add origin https://github.com/SAEEOL/handbook.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("handbook")
+    })
+
+    test("extracts repo name from SSH git URL", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          // Set git origin to SSH URL
+          await Bun.$`git remote add origin git@github.com:SAEEOL/handbook.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("handbook")
+    })
+
+    test("extracts repo name from HTTPS URL without .git extension", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await Bun.$`git remote add origin https://github.com/SAEEOL/handbook`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("handbook")
+    })
+
+    test("extracts repo name from ssh:// URL", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await Bun.$`git remote add origin ssh://git@github.com/SAEEOL/handbook.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("handbook")
+    })
+
+    test("truncates long repo names to 100 characters", async () => {
+      const longName = "a".repeat(150)
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await Bun.$`git remote add origin https://github.com/SAEEOL/${longName}.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe(longName.slice(-100))
+    })
+  })
+
+  describe("config file priority", () => {
+    test("uses project.id from .saeeol/config.json", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          // Create config with project ID
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(
+            path.join(dir, ".saeeol", "config.json"),
+            JSON.stringify({
+              project: {
+                id: "my-custom-project",
+              },
+            }),
+          )
+
+          // Also set git origin - config should take priority
+          await Bun.$`git remote add origin https://github.com/SAEEOL/handbook.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("my-custom-project")
+    })
+
+    test("reads .saeeol/config.json", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(
+            path.join(dir, ".saeeol", "config.json"),
+            JSON.stringify({
+              project: {
+                id: "legacy-project",
+              },
+            }),
+          )
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("legacy-project")
+    })
+
+    test("reads .saeeol/config.json", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(path.join(dir, ".saeeol", "config.json"), JSON.stringify({ project: { id: "new-project" } }))
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(
+            path.join(dir, ".saeeol", "config.json"),
+            JSON.stringify({ project: { id: "old-project" } }),
+          )
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("new-project")
+    })
+
+    test("normalizes git URL in config file project.id", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(
+            path.join(dir, ".saeeol", "config.json"),
+            JSON.stringify({
+              project: {
+                id: "https://github.com/SAEEOL/another-repo.git",
+              },
+            }),
+          )
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("another-repo")
+    })
+
+    test("falls back to git origin when config file has no project.id", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(
+            path.join(dir, ".saeeol", "config.json"),
+            JSON.stringify({
+              project: {
+                managedIndexingEnabled: true,
+              },
+            }),
+          )
+
+          await Bun.$`git remote add origin https://github.com/SAEEOL/handbook.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("handbook")
+    })
+
+    test("falls back to git origin when config has empty project.id", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(
+            path.join(dir, ".saeeol", "config.json"),
+            JSON.stringify({
+              project: {
+                id: "",
+              },
+            }),
+          )
+
+          await Bun.$`git remote add origin https://github.com/SAEEOL/handbook.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("handbook")
+    })
+
+    test("trims whitespace from config file project.id", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(
+            path.join(dir, ".saeeol", "config.json"),
+            JSON.stringify({
+              project: {
+                id: "  my-project\n",
+              },
+            }),
+          )
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("my-project")
+    })
+
+    test("falls back to git when config has whitespace-only project.id", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(
+            path.join(dir, ".saeeol", "config.json"),
+            JSON.stringify({
+              project: {
+                id: "  \n\t  ",
+              },
+            }),
+          )
+
+          await Bun.$`git remote add origin https://github.com/SAEEOL/handbook.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("handbook")
+    })
+  })
+
+  describe("fallback behavior", () => {
+    test("returns undefined when no config and no git origin", async () => {
+      await using tmp = await tmpdir({ git: true })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBeUndefined()
+    })
+
+    test("returns undefined for non-git directory", async () => {
+      await using tmp = await tmpdir()
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBeUndefined()
+    })
+
+    test("handles malformed JSON in config file gracefully", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(path.join(dir, ".saeeol", "config.json"), "{ invalid json")
+
+          await Bun.$`git remote add origin https://github.com/SAEEOL/handbook.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      // Should fall back to git origin
+      expect(id).toBe("handbook")
+    })
+
+    test("handles config file with non-string project.id", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(
+            path.join(dir, ".saeeol", "config.json"),
+            JSON.stringify({
+              project: {
+                id: 12345,
+              },
+            }),
+          )
+
+          await Bun.$`git remote add origin https://github.com/SAEEOL/handbook.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      // Should fall back to git origin
+      expect(id).toBe("handbook")
+    })
+  })
+
+  describe("caching", () => {
+    test("caches project ID per Instance", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await Bun.$`git remote add origin https://github.com/SAEEOL/handbook.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id1 = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      const id2 = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id1).toBe(id2)
+      expect(id1).toBe("handbook")
+    })
+  })
+
+  describe("edge cases", () => {
+    test("handles git URLs with port numbers", async () => {
+      await using tmp = await tmpdir({
+        git: true,
+        init: async (dir) => {
+          await Bun.$`git remote add origin https://github.com:443/SAEEOL/handbook.git`.cwd(dir).quiet()
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("handbook")
+    })
+
+    test("handles plain string project IDs from config", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(
+            path.join(dir, ".saeeol", "config.json"),
+            JSON.stringify({
+              project: {
+                id: "simple-name",
+              },
+            }),
+          )
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe("simple-name")
+    })
+
+    test("truncates plain string project IDs to 100 chars", async () => {
+      const longId = "x".repeat(150)
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await fs.mkdir(path.join(dir, ".saeeol"), { recursive: true })
+          await Bun.write(
+            path.join(dir, ".saeeol", "config.json"),
+            JSON.stringify({
+              project: {
+                id: longId,
+              },
+            }),
+          )
+        },
+      })
+
+      const id = await Instance.provide({
+        directory: tmp.path,
+        fn: () => getSaeeolProjectId(),
+      })
+
+      expect(id).toBe(longId.slice(-100))
+    })
+  })
+})