onlycode 1.18.0 → 1.19.0

package/src/cli/cmd/run/scrollback.shared.ts

@@ -1,92 +0,0 @@
-import { SyntaxStyle, TextAttributes, type ColorInput } from "@opentui/core"
-import { type RunEntryTheme, type RunTheme } from "./theme"
-import type { StreamCommit } from "./types"
-
-function syntax(style?: SyntaxStyle): SyntaxStyle {
-  return style ?? SyntaxStyle.fromTheme([])
-}
-
-export function entrySyntax(commit: StreamCommit, theme: RunTheme): SyntaxStyle {
-  if (commit.kind === "reasoning") {
-    return syntax(theme.block.subtleSyntax ?? theme.block.syntax)
-  }
-
-  return syntax(theme.block.syntax)
-}
-
-export function entryFailed(commit: StreamCommit): boolean {
-  return commit.kind === "tool" && (commit.toolState === "error" || commit.part?.state.status === "error")
-}
-
-export function entryLook(commit: StreamCommit, theme: RunEntryTheme): { fg: ColorInput; attrs?: number } {
-  if (commit.kind === "user") {
-    return {
-      fg: theme.user.body,
-      //attrs: TextAttributes.BOLD,
-    }
-  }
-
-  if (entryFailed(commit)) {
-    return {
-      fg: theme.error.body,
-      attrs: TextAttributes.BOLD,
-    }
-  }
-
-  if (commit.phase === "final") {
-    return {
-      fg: theme.system.body,
-      attrs: TextAttributes.DIM,
-    }
-  }
-
-  if (commit.kind === "tool" && commit.phase === "start") {
-    return {
-      fg: theme.tool.start ?? theme.tool.body,
-    }
-  }
-
-  if (commit.kind === "assistant") {
-    return { fg: theme.assistant.body }
-  }
-
-  if (commit.kind === "reasoning") {
-    return {
-      fg: theme.reasoning.body,
-      attrs: TextAttributes.DIM,
-    }
-  }
-
-  if (commit.kind === "error") {
-    return {
-      fg: theme.error.body,
-      attrs: TextAttributes.BOLD,
-    }
-  }
-
-  if (commit.kind === "tool") {
-    return { fg: theme.tool.body }
-  }
-
-  return { fg: theme.system.body }
-}
-
-export function entryColor(commit: StreamCommit, theme: RunTheme): ColorInput {
-  if (commit.kind === "assistant") {
-    return theme.entry.assistant.body
-  }
-
-  if (commit.kind === "reasoning") {
-    return theme.entry.reasoning.body
-  }
-
-  if (entryFailed(commit)) {
-    return theme.entry.error.body
-  }
-
-  if (commit.kind === "tool") {
-    return theme.block.text
-  }
-
-  return entryLook(commit, theme.entry).fg
-}

package/src/cli/cmd/run/scrollback.surface.ts

@@ -1,431 +0,0 @@
-// Retained streaming append logic for direct-mode scrollback.
-//
-// Static entries are rendered through `scrollback.writer.tsx`. This file only
-// keeps the retained-surface machinery needed for streaming assistant,
-// reasoning, and tool progress entries that need stable markdown/code layout
-// while content is still arriving.
-import {
-  CodeRenderable,
-  MarkdownRenderable,
-  TextRenderable,
-  getTreeSitterClient,
-  type TreeSitterClient,
-  type CliRenderer,
-  type ScrollbackSurface,
-} from "@opentui/core"
-import { entryBody, entryCanStream, entryDone, entryFlags } from "./entry.body"
-import { entryColor, entryLook, entrySyntax } from "./scrollback.shared"
-import { turnSummaryCommit } from "./turn-summary"
-import { entryWriter, sameEntryGroup, separatorRows, spacerWriter, turnSummaryWriter } from "./scrollback.writer"
-import { type RunTheme } from "./theme"
-import type { RunDiffStyle, RunEntryBody, StreamCommit } from "./types"
-
-type ActiveBody = Exclude<RunEntryBody, { type: "none" | "structured" }>
-
-type ActiveEntry = {
-  body: ActiveBody
-  commit: StreamCommit
-  surface: ScrollbackSurface
-  renderable: TextRenderable | CodeRenderable | MarkdownRenderable
-  content: string
-  committedRows: number
-  committedBlocks: number
-  pendingSpacerRows: number
-  rendered: boolean
-}
-
-function commitMarkdownBlocks(input: {
-  surface: ScrollbackSurface
-  renderable: MarkdownRenderable
-  startBlock: number
-  endBlockExclusive: number
-  trailingNewline: boolean
-  beforeCommit?: () => void
-}) {
-  if (input.endBlockExclusive <= input.startBlock) {
-    return false
-  }
-
-  const first = input.renderable._blockStates[input.startBlock]
-  const last = input.renderable._blockStates[input.endBlockExclusive - 1]
-  if (!first || !last) {
-    return false
-  }
-
-  const next = input.renderable._blockStates[input.endBlockExclusive]
-  const start = first.renderable.y
-  const end = next ? next.renderable.y : last.renderable.y + last.renderable.height
-
-  input.beforeCommit?.()
-  input.surface.commitRows(start, end, {
-    trailingNewline: input.trailingNewline,
-  })
-  return true
-}
-
-function staticBody(commit: StreamCommit, body: RunEntryBody, spaced: number): RunEntryBody {
-  if (spaced === 0 || body.type !== "text") {
-    return body
-  }
-
-  if (commit.kind !== "tool" || commit.phase !== "progress" || commit.toolState !== "completed") {
-    return body
-  }
-
-  if (!body.content.startsWith("\n")) {
-    return body
-  }
-
-  return {
-    ...body,
-    content: body.content.replace(/^\n/, ""),
-  }
-}
-
-export class RunScrollbackStream {
-  private tail: StreamCommit | undefined
-  private rendered: StreamCommit | undefined
-  private active: ActiveEntry | undefined
-  private diffStyle: RunDiffStyle | undefined
-  private sessionID?: () => string | undefined
-  private treeSitterClient: TreeSitterClient | undefined
-  private wrote: boolean
-  private pendingThemes: RunTheme[] = []
-
-  constructor(
-    private renderer: CliRenderer,
-    private theme: RunTheme,
-    options: {
-      wrote?: boolean
-      diffStyle?: RunDiffStyle
-      sessionID?: () => string | undefined
-      treeSitterClient?: TreeSitterClient
-      onThemeRelease?: (theme: RunTheme) => void
-    } = {},
-  ) {
-    this.diffStyle = options.diffStyle
-    this.sessionID = options.sessionID
-    this.treeSitterClient = options.treeSitterClient ?? getTreeSitterClient()
-    this.wrote = options.wrote ?? false
-    this.onThemeRelease = options.onThemeRelease
-  }
-
-  private onThemeRelease: ((theme: RunTheme) => void) | undefined
-
-  private releasePendingThemes(): void {
-    if (this.pendingThemes.length === 0) {
-      return
-    }
-
-    for (const theme of this.pendingThemes.splice(0)) this.onThemeRelease?.(theme)
-  }
-
-  public setTheme(theme: RunTheme): void {
-    if (this.theme === theme) {
-      return
-    }
-
-    const previous = this.theme
-    this.theme = theme
-    const active = this.active
-    if (!active) {
-      this.onThemeRelease?.(previous)
-      return
-    }
-
-    this.pendingThemes.push(previous)
-
-    const style = entryLook(active.commit, theme.entry)
-    if (active.renderable instanceof TextRenderable) {
-      active.renderable.fg = style.fg
-      active.renderable.attributes = style.attrs ?? 0
-      return
-    }
-
-    active.renderable.fg = entryColor(active.commit, theme)
-    active.renderable.syntaxStyle = entrySyntax(active.commit, theme)
-  }
-
-  private createEntry(commit: StreamCommit, body: ActiveBody): ActiveEntry {
-    const surface = this.renderer.createScrollbackSurface({
-      startOnNewLine: entryFlags(commit).startOnNewLine,
-    })
-    const style = entryLook(commit, this.theme.entry)
-    const renderable =
-      body.type === "text"
-        ? new TextRenderable(surface.renderContext, {
-            content: "",
-            width: "100%",
-            wrapMode: "word",
-            fg: style.fg,
-            attributes: style.attrs,
-          })
-        : body.type === "code"
-          ? new CodeRenderable(surface.renderContext, {
-              content: "",
-              filetype: body.filetype,
-              syntaxStyle: entrySyntax(commit, this.theme),
-              width: "100%",
-              wrapMode: "word",
-              drawUnstyledText: false,
-              streaming: true,
-              fg: entryColor(commit, this.theme),
-              treeSitterClient: this.treeSitterClient,
-            })
-          : new MarkdownRenderable(surface.renderContext, {
-              content: "",
-              syntaxStyle: entrySyntax(commit, this.theme),
-              width: "100%",
-              streaming: true,
-              internalBlockMode: "top-level",
-              tableOptions: { widthMode: "content" },
-              fg: entryColor(commit, this.theme),
-              treeSitterClient: this.treeSitterClient,
-            })
-
-    surface.root.add(renderable)
-
-    const rows = separatorRows(this.rendered, commit, body)
-
-    return {
-      body,
-      commit,
-      surface,
-      renderable,
-      content: "",
-      committedRows: 0,
-      committedBlocks: 0,
-      pendingSpacerRows: rows || (!this.rendered && this.wrote ? 1 : 0),
-      rendered: false,
-    }
-  }
-
-  private markRendered(commit: StreamCommit | undefined): void {
-    if (!commit) {
-      return
-    }
-
-    this.rendered = commit
-  }
-
-  private writeSpacer(rows: number): void {
-    if (rows === 0) {
-      return
-    }
-
-    this.renderer.writeToScrollback(spacerWriter())
-    this.wrote = false
-  }
-
-  private flushPendingSpacer(active: ActiveEntry): void {
-    this.writeSpacer(active.pendingSpacerRows)
-    active.pendingSpacerRows = 0
-  }
-
-  private async flushActive(done: boolean, trailingNewline: boolean): Promise<boolean> {
-    const active = this.active
-    if (!active) {
-      return false
-    }
-
-    if (active.body.type === "text") {
-      if (!(active.renderable instanceof TextRenderable)) {
-        return false
-      }
-
-      const renderable = active.renderable
-      renderable.content = active.content
-      active.surface.render()
-      this.releasePendingThemes()
-      const targetRows = done ? active.surface.height : Math.max(active.committedRows, active.surface.height - 1)
-      if (targetRows <= active.committedRows) {
-        return false
-      }
-
-      this.flushPendingSpacer(active)
-      active.surface.commitRows(active.committedRows, targetRows, {
-        trailingNewline: done && targetRows === active.surface.height ? trailingNewline : false,
-      })
-      active.committedRows = targetRows
-      active.rendered = true
-      return true
-    }
-
-    if (active.body.type === "code") {
-      if (!(active.renderable instanceof CodeRenderable)) {
-        return false
-      }
-
-      const renderable = active.renderable
-      renderable.content = active.content
-      renderable.streaming = !done
-      await active.surface.settle()
-      this.releasePendingThemes()
-      const targetRows = done ? active.surface.height : Math.max(active.committedRows, active.surface.height - 1)
-      if (targetRows <= active.committedRows) {
-        return false
-      }
-
-      this.flushPendingSpacer(active)
-      active.surface.commitRows(active.committedRows, targetRows, {
-        trailingNewline: done && targetRows === active.surface.height ? trailingNewline : false,
-      })
-      active.committedRows = targetRows
-      active.rendered = true
-      return true
-    }
-
-    if (!(active.renderable instanceof MarkdownRenderable)) {
-      return false
-    }
-
-    const renderable = active.renderable
-    renderable.content = active.content
-    renderable.streaming = !done
-    await active.surface.settle()
-    this.releasePendingThemes()
-    const targetBlockCount = done ? renderable._blockStates.length : renderable._stableBlockCount
-    if (targetBlockCount <= active.committedBlocks) {
-      return false
-    }
-
-    if (
-      commitMarkdownBlocks({
-        surface: active.surface,
-        renderable,
-        startBlock: active.committedBlocks,
-        endBlockExclusive: targetBlockCount,
-        trailingNewline: done && targetBlockCount === renderable._blockStates.length ? trailingNewline : false,
-        beforeCommit: () => this.flushPendingSpacer(active),
-      })
-    ) {
-      active.committedBlocks = targetBlockCount
-      active.rendered = true
-      return true
-    }
-
-    return false
-  }
-
-  private async finishActive(trailingNewline: boolean): Promise<StreamCommit | undefined> {
-    if (!this.active) {
-      return undefined
-    }
-
-    const active = this.active
-
-    try {
-      await this.flushActive(true, trailingNewline)
-    } finally {
-      if (this.active === active) {
-        this.active = undefined
-      }
-
-      if (!active.surface.isDestroyed) {
-        active.surface.destroy()
-      }
-      this.releasePendingThemes()
-    }
-
-    return active.rendered ? active.commit : undefined
-  }
-
-  private async writeStreaming(commit: StreamCommit, body: ActiveBody): Promise<void> {
-    if (!this.active || !sameEntryGroup(this.active.commit, commit) || this.active.body.type !== body.type) {
-      this.markRendered(await this.finishActive(false))
-      this.active = this.createEntry(commit, body)
-    }
-
-    this.active.body = body
-    this.active.commit = commit
-    this.active.content += body.content
-    await this.flushActive(false, false)
-    if (this.active.rendered) {
-      this.markRendered(this.active.commit)
-    }
-  }
-
-  public async append(commit: StreamCommit): Promise<void> {
-    const same = sameEntryGroup(this.tail, commit)
-    if (!same) {
-      this.markRendered(await this.finishActive(false))
-    }
-
-    if (commit.summary) {
-      this.writeSpacer(1)
-      this.renderer.writeToScrollback(turnSummaryWriter({ ...commit.summary, theme: this.theme }))
-      this.markRendered(commit)
-      this.tail = commit
-      return
-    }
-
-    const body = entryBody(commit)
-    if (body.type === "none") {
-      if (entryDone(commit)) {
-        this.markRendered(await this.finishActive(false))
-      }
-
-      this.tail = commit
-      return
-    }
-
-    if (
-      body.type !== "structured" &&
-      (entryCanStream(commit, body) || (commit.kind === "tool" && commit.phase === "final" && body.type === "markdown"))
-    ) {
-      await this.writeStreaming(commit, body)
-      if (entryDone(commit)) {
-        this.markRendered(await this.finishActive(false))
-      }
-      this.tail = commit
-      return
-    }
-
-    if (same) {
-      this.markRendered(await this.finishActive(false))
-    }
-
-    const rows = separatorRows(this.rendered, commit, body)
-    const spaced = rows || (!this.rendered && this.wrote ? 1 : 0)
-    this.writeSpacer(spaced)
-
-    this.renderer.writeToScrollback(
-      entryWriter({
-        commit,
-        body: staticBody(commit, body, spaced),
-        theme: this.theme,
-        opts: {
-          diffStyle: this.diffStyle,
-        },
-      }),
-    )
-    this.markRendered(commit)
-    this.tail = commit
-  }
-
-  private resetActive(): void {
-    if (!this.active) {
-      return
-    }
-
-    if (!this.active.surface.isDestroyed) {
-      this.active.surface.destroy()
-    }
-
-    this.active = undefined
-    this.releasePendingThemes()
-  }
-
-  public async complete(trailingNewline = false): Promise<void> {
-    this.markRendered(await this.finishActive(trailingNewline))
-  }
-
-  public async writeTurnSummary(input: { agent: string; model: string; duration: string }): Promise<void> {
-    await this.append(turnSummaryCommit(input))
-  }
-
-  public destroy(): void {
-    this.resetActive()
-    this.releasePendingThemes()
-  }
-}