@neurocode-ai/app 1.18.8

package/src/pages/session/timeline/row-reconciliation.ts

@@ -0,0 +1,56 @@
+import { TimelineRow } from "./timeline-row"
+
+type ContextRow = Extract<TimelineRow.TimelineRow, { _tag: "AssistantPart" }>
+type PriorContext = { index: number; row: ContextRow }
+
+export function reuseTimelineRows(previous: TimelineRow.TimelineRow[] | undefined, rows: TimelineRow.TimelineRow[]) {
+  if (!previous?.length) return rows
+  const byKey = new Map(previous.map((row) => [TimelineRow.key(row), row] as const))
+  const contextByPart = new Map<string, PriorContext>()
+  previous.forEach((row, index) => {
+    if (row._tag !== "AssistantPart" || row.group.type !== "context") return
+    row.group.refs.forEach((ref) => contextByPart.set(`${row.userMessageID}:${ref.partID}`, { index, row }))
+  })
+  const reserved = new Map<string, number>()
+  rows.forEach((row, index) => {
+    if (row._tag !== "AssistantPart" || row.group.type !== "context") return
+    const key = TimelineRow.key(row)
+    if (byKey.has(key) && !reserved.has(key)) reserved.set(key, index)
+  })
+  const claimed = new Set<string>()
+  const next = rows.map((input, index) => {
+    const row = stabilizeContextKey(contextByPart, reserved, input, index, claimed)
+    const existing = byKey.get(TimelineRow.key(row))
+    if (!existing) return row
+    return TimelineRow.equals(existing, row) ? existing : row
+  })
+  if (previous.length === next.length && previous.every((row, index) => row === next[index])) return previous
+  return next
+}
+
+function stabilizeContextKey(
+  contextByPart: Map<string, PriorContext>,
+  reserved: Map<string, number>,
+  row: TimelineRow.TimelineRow,
+  rowIndex: number,
+  claimed: Set<string>,
+) {
+  if (row._tag !== "AssistantPart" || row.group.type !== "context") return row
+  const existing = row.group.refs.reduce<PriorContext | undefined>((result, ref) => {
+    const candidate = contextByPart.get(`${row.userMessageID}:${ref.partID}`)
+    if (!candidate) return result
+    const key = TimelineRow.key(candidate.row)
+    if (claimed.has(key)) return result
+    const owner = reserved.get(key)
+    if (owner !== undefined && owner !== rowIndex) return result
+    return !result || candidate.index < result.index ? candidate : result
+  }, undefined)
+  if (!existing) return row
+  const key = TimelineRow.key(existing.row)
+  claimed.add(key)
+  if (row.group.key === existing.row.group.key) return row
+  return new TimelineRow.AssistantPart({
+    ...row,
+    group: { ...row.group, key: existing.row.group.key },
+  })
+}

package/src/pages/session/timeline/rows-current.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, mock, test } from "bun:test"
+import type { SessionMessageInfo } from "@neurocode-ai/client/promise"
+import { normalizeSessionMessages } from "@/utils/session-message"
+
+mock.module("@neurocode-ai/session-ui/message-part", () => ({
+  renderable: () => true,
+  groupParts: (refs: Array<{ messageID: string; part: { id: string } }>) =>
+    refs.map((ref) => ({
+      type: "part" as const,
+      key: ref.part.id,
+      ref: { messageID: ref.messageID, partID: ref.part.id },
+    })),
+}))
+
+const { Timeline, TimelineRow } = await import("./rows")
+
+describe("current session timeline rows", () => {
+  test("derives turns and tagged rows from chronological current messages", () => {
+    const source = [
+      { id: "msg_1", type: "user", text: "first", time: { created: 1 } },
+      {
+        id: "msg_2",
+        type: "assistant",
+        agent: "build",
+        model: { id: "model", providerID: "provider" },
+        content: [{ type: "text", text: "answer" }],
+        time: { created: 2, completed: 3 },
+      },
+      { id: "msg_3", type: "user", text: "second", time: { created: 4 } },
+      {
+        id: "msg_4",
+        type: "assistant",
+        agent: "build",
+        model: { id: "model", providerID: "provider" },
+        content: [{ type: "reasoning", text: "working" }],
+        time: { created: 5 },
+      },
+    ] satisfies SessionMessageInfo[]
+    const normalized = normalizeSessionMessages("ses_1", source)
+    const messages = new Map(normalized.messages.map((message) => [message.id, message]))
+
+    const result = Timeline.constructSessionMessageRows(
+      source,
+      (messageID) => messages.get(messageID),
+      (messageID) => normalized.parts.get(messageID) ?? [],
+      true,
+      "busy",
+      true,
+      normalized.messages.filter((message) => message.role === "user"),
+    )
+
+    expect(result.activeMessageID).toBe("msg_3")
+    expect(result.rows.map(TimelineRow.key)).toEqual([
+      "user-message:msg_1",
+      "assistant-part:msg_1:msg_2:text:0",
+      "turn-gap:msg_3",
+      "user-message:msg_3",
+      "assistant-part:msg_3:msg_4:reasoning:0",
+    ])
+  })
+
+  test("renders a current shell message as a standalone turn", () => {
+    const source = [
+      {
+        id: "msg_shell",
+        type: "shell",
+        shellID: "shell_1",
+        command: "pwd",
+        status: "exited",
+        exit: 0,
+        output: { output: "/repo", cursor: 5, size: 5, truncated: false },
+        time: { created: 1, completed: 2 },
+      },
+    ] satisfies SessionMessageInfo[]
+    const normalized = normalizeSessionMessages("ses_1", source)
+    const messages = new Map(normalized.messages.map((message) => [message.id, message]))
+
+    const result = Timeline.constructSessionMessageRows(
+      source,
+      (messageID) => messages.get(messageID),
+      (messageID) => normalized.parts.get(messageID) ?? [],
+      true,
+      "idle",
+      true,
+      normalized.messages.filter((message) => message.role === "user"),
+    )
+
+    expect(result.activeMessageID).toBe("msg_shell")
+    expect(result.rows.map(TimelineRow.key)).toEqual([
+      "user-message:msg_shell",
+      "assistant-part:msg_shell:msg_shell:tool",
+    ])
+  })
+
+  test("keeps a projected parent missing from the source page before newer turns", () => {
+    const source = [
+      { id: "msg_user_1", type: "user", text: "first question", time: { created: 1 } },
+      {
+        id: "msg_assistant_1",
+        type: "assistant",
+        agent: "build",
+        model: { id: "model", providerID: "provider" },
+        content: [{ type: "text", text: "first answer" }],
+        time: { created: 2, completed: 3 },
+      },
+      { id: "msg_user_2", type: "user", text: "second question", time: { created: 4 } },
+      {
+        id: "msg_assistant_2",
+        type: "assistant",
+        agent: "build",
+        model: { id: "model", providerID: "provider" },
+        content: [{ type: "text", text: "second answer" }],
+        time: { created: 5, completed: 6 },
+      },
+    ] satisfies SessionMessageInfo[]
+    const normalized = normalizeSessionMessages("ses_1", source)
+    const messages = new Map(normalized.messages.map((message) => [message.id, message]))
+
+    const result = Timeline.constructSessionMessageRows(
+      source.slice(1),
+      (messageID) => messages.get(messageID),
+      (messageID) => normalized.parts.get(messageID) ?? [],
+      true,
+      "idle",
+      true,
+      normalized.messages.filter((message) => message.role === "user"),
+    )
+
+    expect(result.rows.map(TimelineRow.key)).toEqual([
+      "user-message:msg_user_1",
+      "assistant-part:msg_user_1:msg_assistant_1:text:0",
+      "turn-gap:msg_user_2",
+      "user-message:msg_user_2",
+      "assistant-part:msg_user_2:msg_assistant_2:text:0",
+    ])
+  })
+
+  test("renders an optimistic user turn and thinking before the protocol message arrives", () => {
+    const source = [
+      { id: "msg_1", type: "user", text: "existing", time: { created: 1 } },
+    ] satisfies SessionMessageInfo[]
+    const normalized = normalizeSessionMessages("ses_1", source)
+    const optimistic = {
+      id: "msg_2",
+      sessionID: "ses_1",
+      role: "user" as const,
+      time: { created: 2 },
+      agent: "build",
+      model: { modelID: "model", providerID: "provider" },
+    }
+    const result = Timeline.constructSessionMessageRows(
+      source,
+      (messageID) =>
+        messageID === optimistic.id ? optimistic : normalized.messages.find((message) => message.id === messageID),
+      () => [],
+      true,
+      "busy",
+      true,
+      [...normalized.messages.filter((message) => message.role === "user"), optimistic],
+    )
+
+    expect(result.activeMessageID).toBe(optimistic.id)
+    expect(result.rows.map(TimelineRow.key)).toEqual([
+      "user-message:msg_1",
+      "turn-gap:msg_2",
+      "user-message:msg_2",
+      "thinking:msg_2",
+    ])
+  })
+})

package/src/pages/session/timeline/rows.ts

@@ -0,0 +1,344 @@
+import { parseCommentNote, readCommentMetadata } from "@/utils/comment-note"
+import type { SessionMessageInfo } from "@neurocode-ai/client/promise"
+import { AssistantMessage, Part, SessionStatus, UserMessage } from "@neurocode-ai/sdk/v2"
+import { groupParts, renderable, type PartGroup } from "@neurocode-ai/session-ui/message-part"
+import { TimelineRow, type SummaryDiff } from "./timeline-row"
+import { uniqueSummaryDiffs } from "./summary-diffs"
+
+export { TimelineRow, type SummaryDiff } from "./timeline-row"
+
+export type TimelineRowMap = {
+  TurnGap: { userMessageID: string }
+  CommentStrip: {
+    userMessageID: string
+  }
+  UserMessage: {
+    userMessageID: string
+    anchor: boolean
+  }
+  TurnDivider: {
+    userMessageID: string
+    label: "compaction" | "interrupted"
+  }
+  AssistantPart: {
+    userMessageID: string
+    group: PartGroup
+    previousAssistantPart: boolean
+  }
+  Thinking: { userMessageID: string; reasoningHeading?: string }
+  Retry: { userMessageID: string }
+  DiffSummary: { userMessageID: string; diffs: SummaryDiff[] }
+  Error: { userMessageID: string; text: string }
+}
+
+export namespace Timeline {
+  export function constructSessionMessageRows(
+    messages: SessionMessageInfo[],
+    getMessage: (messageID: string) => UserMessage | AssistantMessage | undefined,
+    getMessageParts: (messageID: string) => Part[],
+    showReasoning: boolean,
+    status: SessionStatus["type"],
+    inlineComments: boolean,
+    projectedUserMessages: UserMessage[],
+  ) {
+    const turns: { user: UserMessage; assistants: AssistantMessage[] }[] = []
+    const turnByUserID = new Map<string, (typeof turns)[number]>()
+    messages.forEach((message) => {
+      const projected = getMessage(message.id)
+      if (message.type === "shell" && projected?.role === "user") {
+        const assistant = getMessage(`${message.id}:assistant`)
+        const turn = { user: projected, assistants: assistant?.role === "assistant" ? [assistant] : [] }
+        turns.push(turn)
+        turnByUserID.set(projected.id, turn)
+        return
+      }
+      if (projected?.role === "user") {
+        if (turnByUserID.has(projected.id)) return
+        const turn = { user: projected, assistants: [] }
+        turns.push(turn)
+        turnByUserID.set(projected.id, turn)
+        return
+      }
+      if (projected?.role !== "assistant") return
+      const existing = turnByUserID.get(projected.parentID)
+      if (existing) {
+        existing.assistants.push(projected)
+        return
+      }
+      const user = getMessage(projected.parentID)
+      if (user?.role !== "user") return
+      const turn = { user, assistants: [projected] }
+      turns.push(turn)
+      turnByUserID.set(user.id, turn)
+    })
+    const latestUserMessageID = turns.at(-1)?.user.id
+    projectedUserMessages.forEach((user) => {
+      if (turnByUserID.has(user.id)) return
+      if (latestUserMessageID && user.id < latestUserMessageID) return
+      const turn = { user, assistants: [] }
+      turns.push(turn)
+      turnByUserID.set(user.id, turn)
+    })
+    const activeMessageID = turns.at(-1)?.user.id
+    return {
+      activeMessageID,
+      rows: turns.flatMap((turn, index) =>
+        constructMessageRows(
+          turn.user,
+          getMessageParts,
+          turn.assistants,
+          index,
+          showReasoning,
+          status,
+          turn.user.id === activeMessageID,
+          inlineComments,
+        ),
+      ),
+    }
+  }
+
+  export function constructMessageRows(
+    userMessage: UserMessage,
+    getMessageParts: (messageID: string) => Part[],
+    assistantMessages: AssistantMessage[],
+    index: number,
+    showReasoning: boolean,
+    status: SessionStatus["type"],
+    isActive: boolean,
+    // v2 renders comments inside the user message attachments row instead of a strip row
+    inlineComments: boolean,
+  ) {
+    const rows: TimelineRow.TimelineRow[] = []
+
+    const previousUserMessage = index > 0
+    const userParts = getMessageParts(userMessage.id)
+    const comments = userParts.flatMap((p) => MessageComment.fromPart(p) ?? [])
+    const compaction = userParts.some((p) => p.type === "compaction")
+    const interruptedMessageIndex = assistantMessages.findIndex((m) => m.error?.name === "MessageAbortedError")
+    const interrupted = interruptedMessageIndex !== -1
+    const error = assistantMessages.find((m) => m.error && m.error.name !== "MessageAbortedError")?.error
+
+    const assistantPartRefs = assistantMessages.flatMap((message, messageIndex) =>
+      getMessageParts(message.id)
+        .filter((part) => renderable(part, showReasoning))
+        .map((part) => ({ messageID: message.id, messageIndex, part })),
+    )
+    const assistantItems =
+      interrupted && !compaction
+        ? [
+            ...groupParts(assistantPartRefs.filter((ref) => ref.messageIndex <= interruptedMessageIndex)).map(
+              (group) => ({
+                type: "part" as const,
+                group,
+              }),
+            ),
+            { type: "interrupted" as const },
+            ...groupParts(assistantPartRefs.filter((ref) => ref.messageIndex > interruptedMessageIndex)).map(
+              (group) => ({
+                type: "part" as const,
+                group,
+              }),
+            ),
+          ]
+        : groupParts(assistantPartRefs).map((group) => ({ type: "part" as const, group }))
+    if (previousUserMessage) rows.push(new TimelineRow.TurnGap({ userMessageID: userMessage.id }))
+
+    if (comments.length > 0 && !inlineComments)
+      rows.push(
+        new TimelineRow.CommentStrip({
+          userMessageID: userMessage.id,
+        }),
+      )
+
+    rows.push(
+      new TimelineRow.UserMessage({
+        userMessageID: userMessage.id,
+        anchor: inlineComments || comments.length === 0,
+      }),
+    )
+
+    if (compaction) {
+      rows.push(
+        new TimelineRow.TurnDivider({
+          userMessageID: userMessage.id,
+          label: "compaction",
+        }),
+      )
+    }
+
+    let assistantGroupIndex = 0
+    assistantItems.forEach((item) => {
+      if (item.type === "interrupted") {
+        rows.push(
+          new TimelineRow.TurnDivider({
+            userMessageID: userMessage.id,
+            label: "interrupted",
+          }),
+        )
+        return
+      }
+
+      rows.push(
+        new TimelineRow.AssistantPart({
+          userMessageID: userMessage.id,
+          group: item.group,
+          previousAssistantPart: assistantGroupIndex > 0,
+        }),
+      )
+      assistantGroupIndex += 1
+    })
+
+    if (isActive && status === "busy" && !error && (showReasoning ? assistantPartRefs.length === 0 : true)) {
+      const heading = assistantMessages
+        .flatMap((message) => getMessageParts(message.id))
+        .map((part) => (part.type === "reasoning" && part.text ? reasoningHeading(part.text) : undefined))
+        .find((value): value is string => !!value)
+
+      rows.push(
+        new TimelineRow.Thinking({
+          userMessageID: userMessage.id,
+          reasoningHeading: heading,
+        }),
+      )
+    }
+
+    if (isActive && status === "retry") rows.push(new TimelineRow.Retry({ userMessageID: userMessage.id }))
+
+    const diffs = uniqueSummaryDiffs(userMessage.summary?.diffs)
+    if (diffs.length > 0 && (status === "idle" || !isActive)) {
+      rows.push(
+        new TimelineRow.DiffSummary({
+          userMessageID: userMessage.id,
+          diffs,
+        }),
+      )
+    }
+
+    if (error) {
+      const data = error.data?.message
+      rows.push(
+        new TimelineRow.Error({
+          userMessageID: userMessage.id,
+          text: unwrapErrorMessage(
+            typeof data === "string" ? data : data === undefined || data === null ? "" : String(data),
+          ),
+        }),
+      )
+    }
+
+    return rows
+  }
+
+  function reasoningHeading(text: string) {
+    const markdown = text.replace(/\r\n?/g, "\n")
+    const html = markdown.match(/<h[1-6][^>]*>([\s\S]*?)<\/h[1-6]>/i)
+    if (html?.[1]) {
+      const value = cleanHeading(html[1].replace(/<[^>]+>/g, " "))
+      if (value) return value
+    }
+
+    const atx = markdown.match(/^\s{0,3}#{1,6}[ \t]+(.+?)(?:[ \t]+#+[ \t]*)?$/m)
+    if (atx?.[1]) {
+      const value = cleanHeading(atx[1])
+      if (value) return value
+    }
+
+    const setext = markdown.match(/^([^\n]+)\n(?:=+|-+)\s*$/m)
+    if (setext?.[1]) {
+      const value = cleanHeading(setext[1])
+      if (value) return value
+    }
+
+    const strong = markdown.match(/^\s*(?:\*\*|__)(.+?)(?:\*\*|__)\s*$/m)
+    if (strong?.[1]) {
+      const value = cleanHeading(strong[1])
+      if (value) return value
+    }
+  }
+
+  function cleanHeading(value: string) {
+    return value
+      .replace(/`([^`]+)`/g, "$1")
+      .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+      .replace(/[*_~]+/g, "")
+      .trim()
+  }
+
+  function unwrapErrorMessage(message: string) {
+    const text = message.replace(/^Error:\s*/, "").trim()
+
+    const parse = (value: string) => {
+      try {
+        return JSON.parse(value) as unknown
+      } catch {
+        return undefined
+      }
+    }
+
+    const read = (value: string) => {
+      const first = parse(value)
+      if (typeof first !== "string") return first
+      return parse(first.trim())
+    }
+
+    let json = read(text)
+
+    if (json === undefined) {
+      const start = text.indexOf("{")
+      const end = text.lastIndexOf("}")
+      if (start !== -1 && end > start) json = read(text.slice(start, end + 1))
+    }
+
+    if (!record(json)) return message
+
+    const err = record(json.error) ? json.error : undefined
+    if (err) {
+      const type = typeof err.type === "string" ? err.type : undefined
+      const msg = typeof err.message === "string" ? err.message : undefined
+      if (type && msg) return `${type}: ${msg}`
+      if (msg) return msg
+      if (type) return type
+      const code = typeof err.code === "string" ? err.code : undefined
+      if (code) return code
+    }
+
+    const msg = typeof json.message === "string" ? json.message : undefined
+    if (msg) return msg
+
+    const reason = typeof json.error === "string" ? json.error : undefined
+    if (reason) return reason
+
+    return message
+  }
+
+  function record(value: unknown): value is Record<string, unknown> {
+    return !!value && typeof value === "object" && !Array.isArray(value)
+  }
+}
+
+export namespace MessageComment {
+  export type MessageComment = {
+    path: string
+    comment: string
+    selection?: {
+      startLine: number
+      endLine: number
+    }
+  }
+
+  export const fromPart = (part: Part): MessageComment | undefined => {
+    if (part.type !== "text" || !part.synthetic) return
+    const next = readCommentMetadata(part.metadata) ?? parseCommentNote(part.text)
+    if (!next) return
+    return {
+      path: next.path,
+      comment: next.comment,
+      selection: next.selection
+        ? {
+            startLine: next.selection.startLine,
+            endLine: next.selection.endLine,
+          }
+        : undefined,
+    }
+  }
+}

package/src/pages/session/timeline/summary-diffs.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test"
+import type { SnapshotFileDiff } from "@neurocode-ai/sdk/v2"
+import { uniqueSummaryDiffs } from "./summary-diffs"
+
+const diff = (file: string, additions: number) =>
+  ({
+    file,
+    additions,
+    deletions: 0,
+  }) satisfies SnapshotFileDiff
+
+describe("uniqueSummaryDiffs", () => {
+  test("drops entries without files and preserves unique input", () => {
+    const alpha = diff("alpha.ts", 1)
+    const beta = diff("beta.ts", 1)
+    const invalid = { additions: 1, deletions: 0 } satisfies SnapshotFileDiff
+
+    expect(uniqueSummaryDiffs(undefined)).toEqual([])
+    expect(uniqueSummaryDiffs([])).toEqual([])
+    expect(uniqueSummaryDiffs([invalid])).toEqual([])
+
+    const result = uniqueSummaryDiffs([alpha, invalid, beta])
+    expect(result).toEqual([alpha, beta])
+    expect(result[0]).toBe(alpha)
+    expect(result[1]).toBe(beta)
+  })
+
+  test("keeps the last diff per file in the legacy display order", () => {
+    const oldAlpha = diff("alpha.ts", 1)
+    const oldBeta = diff("beta.ts", 1)
+    const newAlpha = diff("alpha.ts", 2)
+    const charlie = diff("charlie.ts", 1)
+    const newBeta = diff("beta.ts", 2)
+
+    const result = uniqueSummaryDiffs([oldAlpha, oldBeta, newAlpha, charlie, newBeta])
+
+    expect(result).toEqual([newAlpha, charlie, newBeta])
+    expect(result[0]).toBe(newAlpha)
+    expect(result[1]).toBe(charlie)
+    expect(result[2]).toBe(newBeta)
+  })
+})

package/src/pages/session/timeline/summary-diffs.ts

@@ -0,0 +1,20 @@
+import type { SnapshotFileDiff } from "@neurocode-ai/sdk/v2"
+import type { SummaryDiff } from "./timeline-row"
+
+export function uniqueSummaryDiffs(diffs: SnapshotFileDiff[] | undefined) {
+  const files = new Set<string>()
+  return (diffs ?? [])
+    .reduceRight<SummaryDiff[]>((result, diff) => {
+      if (!isSummaryDiff(diff)) return result
+      const file = diff.file
+      if (files.has(file)) return result
+      files.add(file)
+      result.push(diff)
+      return result
+    }, [])
+    .reverse()
+}
+
+function isSummaryDiff(diff: SnapshotFileDiff): diff is SummaryDiff {
+  return typeof diff.file === "string"
+}