saeeol 1.3.0 → 1.3.1

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

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

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

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

@@ -0,0 +1,15 @@
+# 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.