saeeol 1.2.5 → 1.2.8

package/test/saeeol/worktree-diff-summary.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { $ } from "bun"
-import fs from "node:fs/promises"
-import path from "node:path"
-import { tmpdir } from "../fixture/fixture"
-import { WorktreeDiff } from "../../src/overlay/review/worktree-diff"
-
-describe("WorktreeDiff summary", () => {
-  async function setup() {
-    return await tmpdir({
-      git: true,
-      init: async (dir) => {
-        await Bun.write(path.join(dir, "tracked.txt"), "hello\n")
-        await $`git add tracked.txt`.cwd(dir).quiet()
-        await $`git commit -m "init"`.cwd(dir).quiet()
-      },
-    })
-  }
-
-  test("summary returns metadata without loading contents", async () => {
-    await using tmp = await setup()
-    await Bun.write(path.join(tmp.path, "tracked.txt"), "hello\nworld\n")
-    await fs.mkdir(path.join(tmp.path, "node_modules", "pkg"), { recursive: true })
-    await Bun.write(path.join(tmp.path, "node_modules", "pkg", "index.js"), "module.exports = 1\n")
-
-    const diffs = await WorktreeDiff.summary({ dir: tmp.path, base: "HEAD" })
-    const tracked = diffs.find((diff) => diff.file === "tracked.txt")
-    const generated = diffs.find((diff) => diff.file === "node_modules/pkg/index.js")
-
-    expect(tracked).toBeDefined()
-    expect(tracked?.tracked).toBe(true)
-    expect(tracked?.summarized).toBe(true)
-    expect(tracked?.before).toBe("")
-    expect(tracked?.after).toBe("")
-    expect(tracked?.status).toBe("modified")
-
-    expect(generated).toBeDefined()
-    expect(generated?.tracked).toBe(false)
-    expect(generated?.generatedLike).toBe(true)
-    expect(generated?.summarized).toBe(true)
-    expect(generated?.before).toBe("")
-    expect(generated?.after).toBe("")
-    expect(generated?.additions).toBe(1)
-    expect(generated?.status).toBe("added")
-    expect(generated?.stamp?.length).toBeGreaterThan(0)
-  })
-
-  test("detail loads one file and computes untracked line counts", async () => {
-    await using tmp = await setup()
-    await fs.mkdir(path.join(tmp.path, "vendor"), { recursive: true })
-    await Bun.write(path.join(tmp.path, "vendor", "bundle.js"), "one\ntwo\nthree\n")
-
-    const diff = await WorktreeDiff.detail({ dir: tmp.path, base: "HEAD", file: "vendor/bundle.js" })
-
-    expect(diff).toBeDefined()
-    expect(diff?.summarized).toBe(false)
-    expect(diff?.tracked).toBe(false)
-    expect(diff?.generatedLike).toBe(true)
-    expect(diff?.before).toBe("")
-    expect(diff?.after).toBe("one\ntwo\nthree\n")
-    expect(diff?.additions).toBe(3)
-    expect(diff?.status).toBe("added")
-  })
-})

package/test/saeeol/worktree-diff.test.ts

@@ -1,223 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { $ } from "bun"
-import { tmpdir } from "../fixture/fixture"
-import path from "path"
-
-/**
- * Tests for the worktree diff logic used by GET /experimental/worktree/diff.
- * Reproduces the exact git commands from the endpoint to verify they work
- * for tracked, staged, and untracked files.
- */
-describe("worktree diff git commands", () => {
-  async function setupRepo() {
-    const tmp = await tmpdir({
-      git: true,
-      init: async (dir) => {
-        // Create an initial file and commit it so we have a base
-        await Bun.write(path.join(dir, "existing.txt"), "hello\n")
-        await $`git add .`.cwd(dir).quiet()
-        await $`git commit -m "add existing.txt"`.cwd(dir).quiet()
-      },
-    })
-    return tmp
-  }
-
-  test("git diff sees committed changes but NOT untracked files", async () => {
-    await using tmp = await setupRepo()
-    const dir = tmp.path
-
-    // Get the current HEAD as our "ancestor" (simulating merge-base)
-    const headResult = await $`git rev-parse HEAD`.cwd(dir).quiet()
-    const ancestor = headResult.stdout.toString().trim()
-
-    // Create an untracked file (agent writes a file but doesn't stage it)
-    await Bun.write(path.join(dir, "life.py"), 'print("hello world")\n')
-
-    // Verify the file exists
-    const exists = await Bun.file(path.join(dir, "life.py")).exists()
-    expect(exists).toBe(true)
-
-    // git diff --name-status does NOT see untracked files
-    const nameStatus = await $`git -c core.quotepath=false diff --name-status --no-renames ${ancestor}`
-      .cwd(dir)
-      .quiet()
-      .nothrow()
-    const nameStatusOutput = nameStatus.stdout.toString().trim()
-    console.log("git diff --name-status output:", JSON.stringify(nameStatusOutput))
-    expect(nameStatusOutput).toBe("") // empty — life.py is untracked
-
-    // git ls-files --others DOES see untracked files
-    const untracked = await $`git ls-files --others --exclude-standard`.cwd(dir).quiet().nothrow()
-    const untrackedOutput = untracked.stdout.toString().trim()
-    console.log("git ls-files --others output:", JSON.stringify(untrackedOutput))
-    expect(untrackedOutput).toContain("life.py")
-  })
-
-  test("git diff sees staged (added) files", async () => {
-    await using tmp = await setupRepo()
-    const dir = tmp.path
-
-    const headResult = await $`git rev-parse HEAD`.cwd(dir).quiet()
-    const ancestor = headResult.stdout.toString().trim()
-
-    // Create and stage a new file
-    await Bun.write(path.join(dir, "staged.py"), 'print("staged")\n')
-    await $`git add staged.py`.cwd(dir).quiet()
-
-    const nameStatus = await $`git -c core.quotepath=false diff --name-status --no-renames ${ancestor}`
-      .cwd(dir)
-      .quiet()
-      .nothrow()
-    const nameStatusOutput = nameStatus.stdout.toString().trim()
-    console.log("git diff --name-status (staged):", JSON.stringify(nameStatusOutput))
-    // git diff <ancestor> (no --cached) compares ancestor to working tree,
-    // which includes staged changes
-    expect(nameStatusOutput).toContain("staged.py")
-  })
-
-  test("git diff sees modifications to tracked files", async () => {
-    await using tmp = await setupRepo()
-    const dir = tmp.path
-
-    const headResult = await $`git rev-parse HEAD`.cwd(dir).quiet()
-    const ancestor = headResult.stdout.toString().trim()
-
-    // Modify existing tracked file without staging
-    await Bun.write(path.join(dir, "existing.txt"), "hello\nmodified\n")
-
-    const nameStatus = await $`git -c core.quotepath=false diff --name-status --no-renames ${ancestor}`
-      .cwd(dir)
-      .quiet()
-      .nothrow()
-    const nameStatusOutput = nameStatus.stdout.toString().trim()
-    console.log("git diff --name-status (modified):", JSON.stringify(nameStatusOutput))
-    expect(nameStatusOutput).toContain("existing.txt")
-  })
-
-  test("full diff pipeline: tracked + untracked combined", async () => {
-    await using tmp = await setupRepo()
-    const dir = tmp.path
-
-    const headResult = await $`git rev-parse HEAD`.cwd(dir).quiet()
-    const ancestor = headResult.stdout.toString().trim()
-
-    // Modify existing file (tracked change)
-    await Bun.write(path.join(dir, "existing.txt"), "hello\nmodified\n")
-    // Create untracked file
-    await Bun.write(path.join(dir, "new-file.py"), 'print("new")\n')
-
-    // Step 1: git diff for tracked changes
-    const nameStatus = await $`git -c core.quotepath=false diff --name-status --no-renames ${ancestor}`
-      .cwd(dir)
-      .quiet()
-      .nothrow()
-    const tracked = new Set<string>()
-    const trackedFiles: string[] = []
-    for (const line of nameStatus.stdout.toString().trim().split("\n")) {
-      if (!line) continue
-      const parts = line.split("\t")
-      const file = parts.slice(1).join("\t")
-      if (file) {
-        tracked.add(file)
-        trackedFiles.push(file)
-      }
-    }
-
-    // Step 2: git ls-files for untracked
-    const untrackedResult = await $`git ls-files --others --exclude-standard`.cwd(dir).quiet().nothrow()
-    const untrackedFiles: string[] = []
-    for (const file of untrackedResult.stdout.toString().trim().split("\n")) {
-      if (!file || tracked.has(file)) continue
-      untrackedFiles.push(file)
-    }
-
-    console.log("tracked files:", trackedFiles)
-    console.log("untracked files:", untrackedFiles)
-
-    expect(trackedFiles).toContain("existing.txt")
-    expect(trackedFiles).not.toContain("new-file.py")
-    expect(untrackedFiles).toContain("new-file.py")
-    expect(untrackedFiles).not.toContain("existing.txt")
-
-    // Combined = both
-    const allFiles = [...trackedFiles, ...untrackedFiles]
-    expect(allFiles).toContain("existing.txt")
-    expect(allFiles).toContain("new-file.py")
-  })
-
-  test("worktree scenario: branch with no new commits, only untracked files", async () => {
-    // This is the exact scenario from the screenshot:
-    // - Worktree created from main
-    // - Agent writes life.py (never committed/staged)
-    // - merge-base HEAD main = HEAD (no divergence)
-    // - git diff shows nothing, git ls-files --others shows life.py
-    await using tmp = await setupRepo()
-    const dir = tmp.path
-
-    // Simulate: worktree is on same commit as base (no new commits)
-    // merge-base HEAD HEAD = HEAD
-    const mergeBase = await $`git merge-base HEAD HEAD`.cwd(dir).quiet()
-    const ancestor = mergeBase.stdout.toString().trim()
-    console.log("ancestor (same as HEAD):", ancestor)
-
-    // Agent writes a file
-    await Bun.write(
-      path.join(dir, "life.py"),
-      `
-import random
-import time
-import os
-
-def create_board(rows, cols):
-    return [[random.choice([0, 1]) for _ in range(cols)] for _ in range(rows)]
-
-print("Game of Life")
-`,
-    )
-
-    // git diff: nothing (HEAD == ancestor, no tracked changes)
-    const nameStatus = await $`git -c core.quotepath=false diff --name-status --no-renames ${ancestor}`
-      .cwd(dir)
-      .quiet()
-      .nothrow()
-    const nameStatusRaw = nameStatus.stdout.toString().trim()
-    console.log("nameStatus raw:", JSON.stringify(nameStatusRaw))
-
-    // git ls-files --others: should find life.py
-    const untrackedResult = await $`git ls-files --others --exclude-standard`.cwd(dir).quiet().nothrow()
-    const untrackedRaw = untrackedResult.stdout.toString().trim()
-    console.log("untracked raw:", JSON.stringify(untrackedRaw))
-
-    expect(untrackedRaw).toContain("life.py")
-
-    // Now simulate the full endpoint logic
-    const seen = new Set<string>()
-    const diffs: { file: string; status: string }[] = []
-
-    // Process tracked changes
-    for (const line of nameStatusRaw.split("\n")) {
-      if (!line) continue
-      const parts = line.split("\t")
-      const file = parts.slice(1).join("\t")
-      if (file) {
-        seen.add(file)
-        diffs.push({ file, status: "modified" })
-      }
-    }
-
-    // Process untracked files
-    if (untrackedResult.exitCode === 0) {
-      for (const file of untrackedRaw.split("\n")) {
-        if (!file || seen.has(file)) continue
-        const f = Bun.file(path.join(dir, file))
-        if (!(await f.exists())) continue
-        diffs.push({ file, status: "added" })
-      }
-    }
-
-    console.log("final diffs:", diffs)
-    expect(diffs.length).toBe(1)
-    expect(diffs[0]!.file).toBe("life.py")
-    expect(diffs[0]!.status).toBe("added")
-  })
-})

package/test/saeeol/worktree-remove-lock.test.ts

@@ -1,82 +0,0 @@
-import { $ } from "bun"
-import { describe, expect } from "bun:test"
-import * as fs from "fs/promises"
-import path from "path"
-import { Effect, Layer } from "effect"
-import * as CrossSpawnSpawner from "@saeeol/core/cross-spawn-spawner"
-import { Worktree } from "../../src/worktree"
-import { provideTmpdirInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const it = testEffect(Layer.mergeAll(Worktree.defaultLayer, CrossSpawnSpawner.defaultLayer))
-
-describe("Worktree.remove lock retries", () => {
-  it.live("retries transient git remove lock failures", () =>
-    provideTmpdirInstance(
-      (root) =>
-        Effect.gen(function* () {
-          const svc = yield* Worktree.Service
-          const name = `remove-retry-${Date.now().toString(36)}`
-          const branch = `saeeol/${name}`
-          const dir = path.join(root, "..", name)
-
-          yield* Effect.promise(() => $`git worktree add --no-checkout -b ${branch} ${dir}`.cwd(root).quiet())
-          yield* Effect.promise(() => $`git reset --hard`.cwd(dir).quiet())
-
-          const real = (yield* Effect.promise(() => $`which git`.quiet().text())).trim()
-          expect(real).toBeTruthy()
-
-          const bin = path.join(root, "bin")
-          const shim = path.join(bin, "git")
-          const state = path.join(bin, "attempt")
-          yield* Effect.promise(() => fs.mkdir(bin, { recursive: true }))
-          yield* Effect.promise(() =>
-            Bun.write(
-              shim,
-              [
-                "#!/bin/bash",
-                `REAL_GIT=${JSON.stringify(real)}`,
-                `STATE=${JSON.stringify(state)}`,
-                'if [ "$1" = "worktree" ] && [ "$2" = "remove" ] && [ ! -f "$STATE" ]; then',
-                '  touch "$STATE"',
-                '  echo "fatal: EBUSY: resource busy or locked, rmdir $4" >&2',
-                "  exit 1",
-                "fi",
-                'exec "$REAL_GIT" "$@"',
-              ].join("\n"),
-            ),
-          )
-          yield* Effect.promise(() => fs.chmod(shim, 0o755))
-
-          const prev = yield* Effect.acquireRelease(
-            Effect.sync(() => {
-              const prev = process.env.PATH ?? ""
-              process.env.PATH = `${bin}${path.delimiter}${prev}`
-              return prev
-            }),
-            (prev) =>
-              Effect.sync(() => {
-                process.env.PATH = prev
-              }),
-          )
-          void prev
-
-          const ok = yield* svc.remove({ directory: dir })
-
-          expect(ok).toBe(true)
-          expect(
-            yield* Effect.promise(() =>
-              fs
-                .stat(dir)
-                .then(() => true)
-                .catch(() => false),
-            ),
-          ).toBe(false)
-
-          const list = yield* Effect.promise(() => $`git worktree list --porcelain`.cwd(root).quiet().text())
-          expect(list).not.toContain(`worktree ${dir}`)
-        }),
-      { git: true },
-    ),
-  )
-})

package/test/server/AGENTS.md

@@ -1,15 +0,0 @@
-# Server Test Guide
-
-Use these patterns for server and HttpApi middleware tests in this directory.
-
-- Prefer focused middleware tests with tiny fake routes over full API route trees when testing routing, context, proxying, or middleware policy.
-- Use `testEffect(...)` with `NodeHttpServer.layerTest` for the primary in-test server and make relative `HttpClient` requests against it.
-- Use `HttpRouter.add(...)` probe routes that expose the context under test, such as `WorkspaceRouteContext`, `InstanceRef`, or `WorkspaceRef`.
-- Compose middleware in the same order as production when testing interactions, for example `instanceRouterMiddleware.combine(workspaceRouterMiddleware)`.
-- For secondary upstream servers, build Effect `NodeHttpServer.layer(...)` into the current test scope with `Layer.build(...)` so the listener stays alive until the test scope exits.
-- Avoid `Bun.serve` when testing Effect HTTP middleware. Keep the test in the Effect HTTP stack unless the production path being tested is Bun-specific.
-- For WebSocket paths, use `Socket.makeWebSocket(...)` from the test client and assert protocol forwarding or frame relay when relevant.
-- Use scoped test layers for flags, database reset, and other global mutable state. Restore flags and reset state in finalizers.
-- Use `tmpdirScoped({ git: true })` plus `Project.use.fromDirectory(dir)` for project-backed requests.
-- If a test needs persisted state without matching runtime state, keep direct database setup inside a narrowly named helper that explains that state.
-- Add comments for non-obvious test topology, especially tests involving both the local test server and a fake upstream server.

package/test/server/contract.test.ts

@@ -1,231 +0,0 @@
-/**
- * contract.test.ts — SAEEOL 서버 계약 테스트
- *
- * closebook 패턴 기반:
- * - response-conformance: Zod 스키마로 응답 바디 적합성 검사
- * - consumer-contract: SDK/클라이언트가 기대하는 API 응답 스키마 검증
- * - stateful-api-testing: 세션 생성 → 목록 조회 순차 테스트
- *
- * Hono app.request()로 실제 HTTP 서버 없이 테스트.
- * Bun test + Effect + zod 검증.
- */
-
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { Flag } from "@saeeol/core/flag/flag"
-import { Server } from "../../src/server/server"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import * as Log from "@saeeol/core/util/log"
-import { z } from "zod"
-
-void Log.init({ print: false })
-
-const original = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
-
-function app(experimental = true) {
-	Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = experimental
-	return experimental ? Server.Default().app : Server.Legacy().app
-}
-
-// ── Zod 스키마 (계약: 클라이언트가 기대하는 응답 형태) ──
-
-const HealthSchema = z.object({
-	healthy: z.boolean(),
-	version: z.string(),
-})
-
-const ConfigSchema = z.object({
-	model: z.string().optional(),
-	username: z.string().optional(),
-}).passthrough()
-
-const SessionListSchema = z.array(z.object({
-	id: z.string(),
-	title: z.string().optional(),
-	createdAt: z.number().optional(),
-}).passthrough())
-
-const SessionCreateSchema = z.object({
-	id: z.string(),
-}).passthrough()
-
-const AgentListSchema = z.array(z.unknown())
-
-// ── 응답 적합성 검증 (closebook: response-conformance) ──
-
-function checkConformance<T extends z.ZodType>(
-	body: unknown,
-	status: number,
-	schema: T,
-	allowedStatuses: number[] = [200],
-): { ok: boolean; violations: string[] } {
-	const violations: string[] = []
-
-	if (!allowedStatuses.includes(status)) {
-		violations.push(`status: expected ${allowedStatuses.join("/")}, got ${status}`)
-	}
-
-	const parsed = schema.safeParse(body)
-	if (!parsed.success) {
-		for (const issue of parsed.error.issues) {
-			violations.push(`${issue.path.join(".") || "(root)"}: ${issue.message}`)
-		}
-	}
-
-	return { ok: violations.length === 0, violations }
-}
-
-// ── 테스트 ──
-
-describe("SAEEOL server contract tests", () => {
-	afterEach(async () => {
-		Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
-		await disposeAllInstances()
-	})
-
-	describe("GET /global/health", () => {
-		test("returns valid health response (legacy)", async () => {
-			const res = await app(false).request("/global/health")
-			const body = await res.json()
-			expect(res.status).toBe(200)
-			const { ok, violations } = checkConformance(body, res.status, HealthSchema)
-			expect(ok).toBe(true)
-			if (!ok) console.error("Health violations:", violations)
-		})
-
-		test("returns valid health response (experimental)", async () => {
-			const res = await app(true).request("/global/health")
-			const body = await res.json()
-			expect(res.status).toBe(200)
-			const { ok, violations } = checkConformance(body, res.status, HealthSchema)
-			expect(ok).toBe(true)
-			if (!ok) console.error("Health violations:", violations)
-		})
-	})
-
-	describe("GET /global/config", () => {
-		test("returns valid config response", async () => {
-			await using tmp = await tmpdir({ config: {} })
-			const res = await app(false).request("/global/config", {
-				headers: { "x-saeeol-directory": tmp.path },
-			})
-			const body = await res.json()
-			const { ok, violations } = checkConformance(body, res.status, ConfigSchema)
-			expect(ok).toBe(true)
-			if (!ok) console.error("Config violations:", violations)
-		})
-	})
-
-	describe("GET /agent", () => {
-		test("returns agent list", async () => {
-			await using tmp = await tmpdir({ config: {} })
-			const res = await app(false).request("/agent", {
-				headers: { "x-saeeol-directory": tmp.path },
-			})
-			const body = await res.json()
-			const { ok, violations } = checkConformance(body, res.status, AgentListSchema)
-			expect(ok).toBe(true)
-			if (!ok) console.error("Agent violations:", violations)
-		})
-	})
-
-	// ── 상태 순차 테스트 (closebook: stateful-api-testing) ──
-
-	describe("session lifecycle", () => {
-		test("create → list flow", async () => {
-			await using tmp = await tmpdir({ git: true, config: {} })
-			const headers = { "x-saeeol-directory": tmp.path, "Content-Type": "application/json" }
-
-			// Step 1: 세션 생성
-			const createRes = await app(false).request("/session", {
-				method: "POST",
-				headers,
-				body: JSON.stringify({ title: "contract-test" }),
-			})
-			const createBody = await createRes.json()
-			const { ok: createOk, violations: createViolations } = checkConformance(
-				createBody,
-				createRes.status,
-				SessionCreateSchema,
-			)
-			expect(createOk).toBe(true)
-			if (!createOk) console.error("Session create violations:", createViolations)
-
-			// Step 2: 세션 목록
-			const listRes = await app(false).request("/session", { headers })
-			const listBody = await listRes.json()
-			const { ok: listOk, violations: listViolations } = checkConformance(
-				listBody,
-				listRes.status,
-				SessionListSchema,
-			)
-			expect(listOk).toBe(true)
-			if (!listOk) console.error("Session list violations:", listViolations)
-			expect(listBody.length).toBeGreaterThanOrEqual(1)
-		})
-	})
-
-	describe("unknown route", () => {
-		test("returns 404 for unknown endpoints", async () => {
-			const res = await app(false).request("/nonexistent")
-			expect(res.status).toBe(404)
-		})
-	})
-
-	// ── 계약 파일 생성 (closebook: consumer-contract) ──
-
-	describe("pact artifact generation", () => {
-		test("collects verified interactions into contract", async () => {
-			await using tmp = await tmpdir({ config: {} })
-			const headers = { "x-saeeol-directory": tmp.path }
-			const interactions = []
-
-			// Health 인터랙션
-			const healthRes = await app(false).request("/global/health")
-			const healthBody = await healthRes.json()
-			interactions.push({
-				description: "health check",
-				providerStates: [],
-				request: { method: "GET", path: "/global/health" },
-				response: { status: healthRes.status, body: healthBody },
-			})
-
-			// Config 인터랙션
-			const configRes = await app(false).request("/global/config", { headers })
-			const configBody = await configRes.json()
-			interactions.push({
-				description: "global config",
-				providerStates: [],
-				request: { method: "GET", path: "/global/config" },
-				response: { status: configRes.status, body: configBody },
-			})
-
-			// Agent 인터랙션
-			const agentRes = await app(false).request("/agent", { headers })
-			const agentBody = await agentRes.json()
-			interactions.push({
-				description: "agent list",
-				providerStates: [],
-				request: { method: "GET", path: "/agent" },
-				response: { status: agentRes.status, body: agentBody },
-			})
-
-			// 계약 파일 검증
-			const pact = {
-				consumer: { name: "saeeol-vscode" },
-				provider: { name: "saeeol-server" },
-				interactions,
-				metadata: { version: "1.0.0" },
-			}
-
-			expect(pact.interactions.length).toBe(3)
-			for (const ix of pact.interactions) {
-				expect(ix).toHaveProperty("description")
-				expect(ix).toHaveProperty("request")
-				expect(ix).toHaveProperty("response")
-				expect(ix.response.status).toBeLessThan(500)
-			}
-		})
-	})
-})