@neurocode-ai/app 1.18.8

package/test-browser/motion-spring.test.ts

@@ -0,0 +1,20 @@
+import { expect, test } from "bun:test"
+import { useSpring } from "@neurocode-ai/ui/motion-spring"
+import { createRoot, createSignal } from "solid-js"
+
+test("snaps spring progress when the session changes", async () => {
+  const state = createRoot((dispose) => {
+    const [target, setTarget] = createSignal(0)
+    const [session, setSession] = createSignal("session-a")
+    const progress = useSpring(target, { visualDuration: 0.3, bounce: 0 }, session)
+    return { dispose, progress, setTarget, setSession }
+  })
+
+  await new Promise<void>(queueMicrotask)
+  state.setTarget(1)
+  expect(state.progress()).toBe(0)
+
+  state.setSession("session-b")
+  expect(state.progress()).toBe(1)
+  state.dispose()
+})

package/test-browser/prompt-attachments.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test"
+import { createRoot } from "solid-js"
+import { createPromptAttachmentsCore } from "@/components/prompt-input/attachments"
+import { createPromptState } from "@/context/prompt"
+
+describe("prompt attachment session ownership", () => {
+  test("adds an asynchronously read image to the session where the read started", async () => {
+    await createRoot(async (dispose) => {
+      const sessions = { A: createPromptState(), B: createPromptState() }
+      let active: "A" | "B" = "A"
+      const attachments = createPromptAttachmentsCore({
+        capture: () => sessions[active].capture(),
+        editor: () => document.createElement("div"),
+      })
+      const pending = attachments.addAttachment(new File([new Uint8Array(1024 * 1024)], "a.png", { type: "image/png" }))
+
+      active = "B"
+      await pending
+
+      expect(images(sessions.A)).toHaveLength(1)
+      expect(images(sessions.B)).toHaveLength(0)
+      dispose()
+    })
+  })
+
+  test("finishes the captured attachment after the active editor is removed", async () => {
+    await createRoot(async (dispose) => {
+      const prompt = createPromptState()
+      let editor: HTMLDivElement | undefined = document.createElement("div")
+      const attachments = createPromptAttachmentsCore({
+        capture: prompt.capture,
+        editor: () => editor,
+      })
+      const pending = attachments.addAttachment(new File([new Uint8Array(1024 * 1024)], "a.png", { type: "image/png" }))
+
+      editor = undefined
+      await pending
+
+      expect(images(prompt)).toHaveLength(1)
+      dispose()
+    })
+  })
+
+  test("keeps every file in a batch on the session where the batch started", async () => {
+    await createRoot(async (dispose) => {
+      const sessions = { A: createPromptState(), B: createPromptState() }
+      let active: "A" | "B" = "A"
+      const attachments = createPromptAttachmentsCore({
+        capture: () => sessions[active].capture(),
+        editor: () => document.createElement("div"),
+      })
+      const pending = attachments.addAttachments([
+        new File([new Uint8Array(1024 * 1024)], "first.png", { type: "image/png" }),
+        new File([new Uint8Array(1024 * 1024)], "second.png", { type: "image/png" }),
+      ])
+
+      active = "B"
+      await pending
+
+      expect(images(sessions.A)).toHaveLength(2)
+      expect(images(sessions.B)).toHaveLength(0)
+      dispose()
+    })
+  })
+
+  test("keeps a delayed native clipboard image on the session where paste started", async () => {
+    await createRoot(async (dispose) => {
+      const sessions = { A: createPromptState(), B: createPromptState() }
+      const read = Promise.withResolvers<File | null>()
+      let active: "A" | "B" = "A"
+      const attachments = createPromptAttachmentsCore({
+        capture: () => sessions[active].capture(),
+        editor: () => document.createElement("div"),
+      })
+      const pending = attachments.addClipboardAttachment(read.promise)
+
+      active = "B"
+      read.resolve(new File([new Uint8Array(1024 * 1024)], "clipboard.png", { type: "image/png" }))
+      await pending
+
+      expect(images(sessions.A)).toHaveLength(1)
+      expect(images(sessions.B)).toHaveLength(0)
+      dispose()
+    })
+  })
+})
+
+function images(prompt: ReturnType<typeof createPromptState>) {
+  return prompt.current().filter((part) => part.type === "image")
+}

package/test-browser/prompt-persistence.test.ts

@@ -0,0 +1,71 @@
+import { beforeAll, describe, expect, mock, test } from "bun:test"
+import type { AsyncStorage } from "@solid-primitives/storage"
+import { createEffect, createRoot } from "solid-js"
+import { ServerScope } from "@/utils/server-scope"
+
+let Prompt: typeof import("@/context/prompt")
+let read: ((value: string | null) => void) | undefined
+
+const storage: AsyncStorage = {
+  getItem: () => new Promise((resolve) => (read = resolve)),
+  setItem: async () => undefined,
+  removeItem: async () => undefined,
+  clear: async () => undefined,
+  key: async () => null,
+  getLength: async () => 0,
+  length: Promise.resolve(0),
+}
+
+beforeAll(async () => {
+  mock.module("@solidjs/router", () => ({
+    useParams: () => ({}),
+    useSearchParams: () => [{}],
+    useLocation: () => ({ pathname: "", query: {} }),
+    useNavigate: () => () => undefined,
+  }))
+  mock.module("@neurocode-ai/ui/context", () => ({
+    createSimpleContext: () => ({
+      use: () => undefined,
+      provider: () => undefined,
+    }),
+  }))
+  mock.module("@/context/platform", () => ({
+    usePlatform: () => ({ platform: "desktop", storage: () => storage }),
+  }))
+
+  Prompt = await import("@/context/prompt")
+})
+
+describe("prompt persistence", () => {
+  test("waits for an async draft to hydrate before reporting ready", async () => {
+    await new Promise<void>((resolve, reject) => {
+      createRoot((dispose) => {
+        const session = Prompt.createPromptSession(ServerScope.local, { draftID: "draft-async" })
+        const ready = Prompt.createPromptReady(() => session)
+
+        expect(ready()).toBe(false)
+        expect(session.current()[0]).toMatchObject({ type: "text", content: "" })
+
+        read?.(
+          JSON.stringify({
+            prompt: [{ type: "text", content: "persisted draft", start: 0, end: 15 }],
+            cursor: 15,
+            context: { items: [] },
+          }),
+        )
+
+        createEffect(() => {
+          if (!ready()) return
+          try {
+            expect(session.current()[0]).toMatchObject({ type: "text", content: "persisted draft" })
+            dispose()
+            resolve()
+          } catch (error) {
+            dispose()
+            reject(error)
+          }
+        })
+      })
+    })
+  })
+})

package/test-browser/prompt-scope.test.ts

@@ -0,0 +1,14 @@
+import { expect, test } from "bun:test"
+import { ServerConnection } from "@/context/server"
+import { selectPromptTab } from "@/context/prompt"
+import type { Tab } from "@/context/tabs"
+
+test("selects the explicitly scoped session tab instead of the active tab", () => {
+  const server = ServerConnection.Key.make("local")
+  const tabs: Tab[] = [
+    { type: "session", server, sessionId: "A" },
+    { type: "session", server, sessionId: "B" },
+  ]
+
+  expect(selectPromptTab(tabs, { dir: "repo", id: "B" }, server)).toBe(tabs[1])
+})

package/test-browser/prompt-submission-state.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test"
+import { createPromptState } from "@/context/prompt"
+import { createPromptSubmissionState } from "@/components/prompt-input/submission-state"
+
+describe("prompt submission state", () => {
+  test("keeps failed submission restoration with the prompt where it started", () => {
+    const target = createPromptState()
+    const submission = createPromptSubmissionState({
+      target,
+      prompt: [{ type: "text", content: "prompt-A", start: 0, end: 8 }],
+      context: [{ key: "file:src/index.ts:undefined:undefined", type: "file", path: "src/index.ts" }],
+    })
+
+    expect(submission.restore()).toEqual({
+      target,
+      prompt: [{ type: "text", content: "prompt-A", start: 0, end: 8 }],
+      context: [{ key: "file:src/index.ts:undefined:undefined", type: "file", path: "src/index.ts" }],
+    })
+  })
+
+  test("moves first-submit restoration and context to the promoted session", () => {
+    const draft = createPromptState()
+    const session = createPromptState()
+    const submission = createPromptSubmissionState({
+      target: draft,
+      prompt: [{ type: "text", content: "first prompt", start: 0, end: 12 }],
+      context: [{ key: "file:src/index.ts:undefined:undefined", type: "file", path: "src/index.ts" }],
+    })
+
+    submission.retarget(session)
+
+    expect(submission.restore()).toEqual({
+      target: session,
+      prompt: [{ type: "text", content: "first prompt", start: 0, end: 12 }],
+      context: [{ key: "file:src/index.ts:undefined:undefined", type: "file", path: "src/index.ts" }],
+    })
+    expect(session.context.items()).toHaveLength(1)
+    expect(session.context.items()[0]).toMatchObject({ type: "file", path: "src/index.ts" })
+  })
+
+  test("clears the original first-submit prompt after retargeting", () => {
+    const workspace = createPromptState()
+    const session = createPromptState()
+    workspace.set([{ type: "text", content: "first prompt", start: 0, end: 12 }])
+    const submission = createPromptSubmissionState({
+      target: workspace,
+      prompt: workspace.current(),
+      context: [],
+    })
+
+    submission.retarget(session)
+    submission.clear()
+
+    expect(workspace.current()[0]).toMatchObject({ type: "text", content: "" })
+    expect(session.current()[0]).toMatchObject({ type: "text", content: "" })
+  })
+
+  test("does not restore over a prompt edited after submission", () => {
+    const target = createPromptState()
+    target.set([{ type: "text", content: "submitted", start: 0, end: 9 }])
+    const submission = createPromptSubmissionState({
+      target,
+      prompt: target.current(),
+      context: [],
+    })
+
+    submission.clear()
+    target.set([{ type: "text", content: "new draft", start: 0, end: 9 }])
+
+    expect(submission.restore()).toBeUndefined()
+    expect(target.current()[0]).toMatchObject({ type: "text", content: "new draft" })
+  })
+})

package/test-browser/prompt-transient-state.test.ts

@@ -0,0 +1,38 @@
+import { expect, test } from "bun:test"
+import { createRoot, createSignal } from "solid-js"
+import { createPromptInputTransientState } from "@/components/prompt-input/transient-state"
+
+test("resets transient prompt input state when the prompt session changes", () => {
+  createRoot((dispose) => {
+    const [identity, setIdentity] = createSignal("A")
+    const [state, setState] = createPromptInputTransientState(identity, 3)
+    setState({
+      popover: "slash",
+      slashMenu: true,
+      slashMenuQuery: "compact",
+      historyIndex: 2,
+      savedPrompt: {
+        prompt: [{ type: "text", content: "draft-A", start: 0, end: 7 }],
+        comments: [],
+      },
+      draggingType: "image",
+      mode: "shell",
+      applyingHistory: true,
+    })
+
+    setIdentity("B")
+
+    expect(state).toMatchObject({
+      popover: null,
+      slashMenu: false,
+      slashMenuQuery: "",
+      historyIndex: -1,
+      savedPrompt: null,
+      placeholder: 3,
+      draggingType: null,
+      mode: "normal",
+      applyingHistory: false,
+    })
+    dispose()
+  })
+})

package/test-browser/review-panel-v2-state.test.ts

@@ -0,0 +1,65 @@
+import { beforeAll, expect, mock, test } from "bun:test"
+import type { AsyncStorage } from "@solid-primitives/storage"
+import { createEffect, createRoot } from "solid-js"
+
+let createReviewPanelV2State: typeof import("@/pages/session/v2/review-panel-v2-state").createReviewPanelV2State
+let read: ((value: string | null) => void) | undefined
+
+const storage: AsyncStorage = {
+  getItem: () => new Promise((resolve) => (read = resolve)),
+  setItem: async () => undefined,
+  removeItem: async () => undefined,
+  clear: async () => undefined,
+  key: async () => null,
+  getLength: async () => 0,
+  length: Promise.resolve(0),
+}
+
+beforeAll(async () => {
+  mock.module("@neurocode-ai/session-ui/v2/session-review-v2", () => ({
+    SESSION_REVIEW_V2_SIDEBAR_WIDTH_DEFAULT: 240,
+    SESSION_REVIEW_V2_SIDEBAR_WIDTH_MIN: 200,
+    SESSION_REVIEW_V2_SIDEBAR_WIDTH_MAX: 480,
+  }))
+  mock.module("@/context/platform", () => ({
+    usePlatform: () => ({ platform: "desktop", storage: () => storage }),
+  }))
+
+  createReviewPanelV2State = (await import("@/pages/session/v2/review-panel-v2-state")).createReviewPanelV2State
+})
+
+test("enables sidebar motion only after custom width hydration", async () => {
+  await new Promise<void>((resolve, reject) => {
+    createRoot((dispose) => {
+      const state = createReviewPanelV2State()
+      const transition =
+        "sidebarTransition" in state && typeof state.sidebarTransition === "function"
+          ? (state.sidebarTransition as () => boolean)
+          : undefined
+
+      try {
+        expect(transition).toBeFunction()
+        expect(transition?.()).toBeFalse()
+        expect(state.sidebarWidth()).toBe(240)
+      } catch (error) {
+        dispose()
+        reject(error)
+        return
+      }
+
+      createEffect(() => {
+        if (!transition?.()) return
+        try {
+          expect(state.sidebarWidth()).toBe(360)
+          dispose()
+          resolve()
+        } catch (error) {
+          dispose()
+          reject(error)
+        }
+      })
+
+      read?.(JSON.stringify({ sidebarOpened: true, sidebarWidth: 360, expandMode: "collapse" }))
+    })
+  })
+})

package/test-browser/session-lineage.test.ts

@@ -0,0 +1,231 @@
+import { expect, test } from "bun:test"
+import { createRoot, createSignal } from "solid-js"
+import { createSessionLineage } from "@/pages/session/session-lineage"
+
+type Lineage = { session: { id: string; directory: string } }
+
+const lineageOf = (id: string): Lineage => ({ session: { id, directory: `/dir/${id}` } })
+
+// Fake sync lineage store: peek reads a reactive cache, resolve returns a
+// deferred promise the test settles or fails explicitly. The lineage memo is
+// live (read below), so it recomputes eagerly on cache/status writes — throws
+// surface at the write site, which is also where the enclosing ErrorBoundary
+// would see them in the app. Assertions wrap write + read to cover both.
+function createFixture(initial: Record<string, Lineage> = {}) {
+  const [cache, setCache] = createSignal(initial)
+  const deferred = new Map<string, PromiseWithResolvers<unknown>>()
+  const resolves: string[] = []
+  return {
+    resolves,
+    lineage: {
+      peek: (id: string) => cache()[id],
+      resolve: (id: string) => {
+        resolves.push(id)
+        const entry = deferred.get(id) ?? Promise.withResolvers<unknown>()
+        deferred.set(id, entry)
+        return entry.promise
+      },
+    },
+    settle(id: string) {
+      setCache({ ...cache(), [id]: lineageOf(id) })
+      deferred.get(id)?.resolve(undefined)
+    },
+    fail(id: string, error: unknown) {
+      deferred.get(id)?.reject(error)
+      // The real store does not cache failures: the inflight request entry is
+      // dropped on rejection so the next resolve retries (server-session.ts).
+      deferred.delete(id)
+    },
+    remove(id: string) {
+      const next = { ...cache() }
+      delete next[id]
+      setCache(next)
+    },
+  }
+}
+
+// Two microtask ticks: one for the resolve promise handed back by the fixture,
+// one for the .then/.catch chain inside createSessionLineage.
+const flush = async () => {
+  await Promise.resolve()
+  await Promise.resolve()
+}
+
+test("resolves an uncached session and exposes its lineage", async () => {
+  await createRoot(async (dispose) => {
+    const fixture = createFixture()
+    const current = createSessionLineage(
+      () => "ses_a",
+      () => fixture.lineage,
+    )
+
+    expect(current()).toBeUndefined()
+    await flush()
+    expect(fixture.resolves).toEqual(["ses_a"])
+
+    fixture.settle("ses_a")
+    await flush()
+    expect(current()?.session.id).toBe("ses_a")
+
+    dispose()
+  })
+})
+
+// Session tabs on the same server share one route instance, so navigating to
+// another session changes the id in place; resolution must follow it instead
+// of reporting the new session as missing.
+test("re-resolves when navigating to an uncached session without a remount", async () => {
+  await createRoot(async (dispose) => {
+    const fixture = createFixture({ ses_a: lineageOf("ses_a") })
+    const [id, setId] = createSignal("ses_a")
+    const current = createSessionLineage(id, () => fixture.lineage)
+
+    await flush()
+    expect(current()?.session.id).toBe("ses_a")
+
+    expect(() => {
+      setId("ses_b")
+      current()
+    }).not.toThrow()
+    expect(fixture.resolves).toEqual(["ses_b"])
+
+    fixture.settle("ses_b")
+    await flush()
+    expect(current()?.session.id).toBe("ses_b")
+
+    dispose()
+  })
+})
+
+// A late failure from a session the user already navigated away from must not
+// poison the currently viewed session.
+test("ignores a stale resolution failure after the target changes", async () => {
+  await createRoot(async (dispose) => {
+    const fixture = createFixture()
+    const [id, setId] = createSignal("ses_a")
+    const current = createSessionLineage(id, () => fixture.lineage)
+
+    await flush()
+    setId("ses_b")
+    fixture.fail("ses_a", new Error("Session not found: ses_a"))
+    await flush()
+
+    expect(() => current()).not.toThrow()
+    fixture.settle("ses_b")
+    await flush()
+    expect(current()?.session.id).toBe("ses_b")
+
+    dispose()
+  })
+})
+
+test("returning to a pruned session re-resolves instead of throwing not found", async () => {
+  await createRoot(async (dispose) => {
+    const fixture = createFixture()
+    const [id, setId] = createSignal("ses_a")
+    const current = createSessionLineage(id, () => fixture.lineage)
+
+    await flush()
+    fixture.settle("ses_a")
+    await flush()
+
+    setId("ses_b")
+    fixture.settle("ses_b")
+    await flush()
+
+    fixture.remove("ses_a")
+    expect(() => {
+      setId("ses_a")
+      current()
+    }).not.toThrow()
+    expect(fixture.resolves).toEqual(["ses_a", "ses_b", "ses_a"])
+
+    fixture.settle("ses_a")
+    await flush()
+    expect(current()?.session.id).toBe("ses_a")
+
+    dispose()
+  })
+})
+
+// A resolution that fails while its session is unfocused must not leave a
+// poisoned status behind: revisiting that session retries cleanly instead of
+// rethrowing the stale failure before the retry can start.
+test("revisiting a session whose resolution failed while unfocused retries cleanly", async () => {
+  await createRoot(async (dispose) => {
+    const fixture = createFixture()
+    const [id, setId] = createSignal("ses_a")
+    const current = createSessionLineage(id, () => fixture.lineage)
+
+    await flush()
+    setId("ses_b")
+    fixture.fail("ses_a", new Error("resolve failed"))
+    await flush()
+
+    expect(() => {
+      setId("ses_a")
+      current()
+    }).not.toThrow()
+    expect(fixture.resolves).toEqual(["ses_a", "ses_b", "ses_a"])
+
+    fixture.settle("ses_a")
+    await flush()
+    expect(current()?.session.id).toBe("ses_a")
+
+    dispose()
+  })
+})
+
+// The lineage accessor is reactive: replacing the sync store (for example after
+// the server context is rebuilt) must gate out the old store's status and
+// re-resolve against the new one instead of fabricating a not-found.
+test("re-resolves against a replaced lineage store", async () => {
+  await createRoot(async (dispose) => {
+    const first = createFixture()
+    const second = createFixture()
+    const [store, setStore] = createSignal(first.lineage)
+    const current = createSessionLineage(() => "ses_a", store)
+
+    await flush()
+    first.settle("ses_a")
+    await flush()
+    expect(current()?.session.id).toBe("ses_a")
+
+    expect(() => {
+      setStore(second.lineage)
+      current()
+    }).not.toThrow()
+    await flush()
+    expect(second.resolves).toEqual(["ses_a"])
+
+    second.settle("ses_a")
+    await flush()
+    expect(current()?.session.id).toBe("ses_a")
+
+    dispose()
+  })
+})
+
+// The viewed session is pinned in the cache, so disappearing after settlement
+// means it was deleted; the boundary must show the not found fallback.
+test("throws not found when the settled session is deleted", async () => {
+  await createRoot(async (dispose) => {
+    const fixture = createFixture()
+    const current = createSessionLineage(
+      () => "ses_a",
+      () => fixture.lineage,
+    )
+
+    await flush()
+    fixture.settle("ses_a")
+    await flush()
+    expect(current()?.session.id).toBe("ses_a")
+
+    expect(() => {
+      fixture.remove("ses_a")
+      current()
+    }).toThrow("Session not found: ses_a")
+
+    dispose()
+  })
+})

package/test-browser/session-ownership.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, test } from "bun:test"
+import { createRoot, createSignal } from "solid-js"
+import { createSessionOwnership } from "@/pages/session/session-ownership"
+
+describe("createSessionOwnership", () => {
+  test("invalidates captured work when its Solid owner is disposed", () => {
+    let current = true
+    createRoot((dispose) => {
+      const owner = createSessionOwnership(() => "A").capture()
+      dispose()
+      current = owner.current()
+    })
+
+    expect(current).toBe(false)
+  })
+
+  test("does not run a continuation after navigation", () => {
+    createRoot((dispose) => {
+      const [session, setSession] = createSignal("A")
+      const owner = createSessionOwnership(session).capture()
+      let ran = false
+
+      setSession("B")
+      owner.run(() => {
+        ran = true
+      })
+
+      expect(ran).toBe(false)
+      dispose()
+    })
+  })
+
+  test("does not revive a continuation after A to B to A navigation", () => {
+    createRoot((dispose) => {
+      const [session, setSession] = createSignal("A")
+      const owner = createSessionOwnership(session).capture()
+
+      setSession("B")
+      setSession("A")
+
+      expect(owner.current()).toBe(false)
+      dispose()
+    })
+  })
+})