@patze/code-cli 0.16.1 → 0.17.0

package/opentui/src/line-parse.ts

@@ -0,0 +1,54 @@
+import type { TranscriptEntryKind } from "./transcript-render.js"
+
+const ANSI_PATTERN = /\x1b\[[0-9;]*m/g
+const LABEL_WIDTH = 7
+
+const ROLE_MAP: Record<string, TranscriptEntryKind> = {
+  you: "user",
+  agent: "assistant",
+  tool: "tool",
+  run: "status",
+}
+
+export function stripAnsi(value: string): string {
+  return value.replace(ANSI_PATTERN, "")
+}
+
+export function parseTranscriptLine(raw: string): {
+  kind: TranscriptEntryKind
+  label: string
+  text: string
+  continuation: boolean
+} | null {
+  const line = stripAnsi(raw)
+  if (!line.trim()) {
+    return null
+  }
+
+  if (line.startsWith(" ".repeat(LABEL_WIDTH))) {
+    return {
+      kind: "assistant",
+      label: "",
+      text: line.slice(LABEL_WIDTH),
+      continuation: true,
+    }
+  }
+
+  const match = line.match(/^(you|agent|tool|run)\s*(.*)$/i)
+  if (!match) {
+    return {
+      kind: "status",
+      label: "info",
+      text: line,
+      continuation: false,
+    }
+  }
+
+  const role = match[1].toLowerCase()
+  return {
+    kind: ROLE_MAP[role] ?? "status",
+    label: role,
+    text: match[2] ?? "",
+    continuation: false,
+  }
+}

package/opentui/src/main.tsx

@@ -0,0 +1,45 @@
+/**
+ * Patze Code OpenTUI shell (cookbook-style TUI).
+ * Default when Bun + deps are available; opt out with PATZE_USE_JS=1 or PATZE_USE_OPENTUI=0.
+ */
+import { CliRenderEvents, type CliRenderer, createCliRenderer } from "@opentui/core"
+import { createRoot } from "@opentui/react"
+import { createElement } from "react"
+
+import { App, parseCwdArg } from "./App.tsx"
+
+function waitUntilDestroyed(renderer: CliRenderer) {
+  if (renderer.isDestroyed) {
+    return Promise.resolve()
+  }
+
+  return new Promise<void>((resolve) => {
+    renderer.once(CliRenderEvents.DESTROY, () => resolve())
+  })
+}
+
+async function main() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("OpenTUI requires a TTY. Use PATZE_USE_JS=1 for piped/non-TTY shells.")
+  }
+
+  const cwd = parseCwdArg()
+  const renderer = await createCliRenderer({
+    exitOnCtrlC: false,
+    maxFps: 30,
+    screenMode: "alternate-screen",
+  })
+  const root = createRoot(renderer)
+
+  try {
+    root.render(createElement(App, { cwd }))
+    await waitUntilDestroyed(renderer)
+  } finally {
+    root.unmount()
+    if (!renderer.isDestroyed) {
+      renderer.destroy()
+    }
+  }
+}
+
+await main()

package/opentui/src/patze-dist.ts

@@ -0,0 +1,11 @@
+import { resolve } from "node:path"
+import { pathToFileURL } from "node:url"
+
+export function resolvePatzePackageRoot(): string {
+  return process.env.PATZE_CLI_PACKAGE_ROOT || resolve(import.meta.dir, "../..")
+}
+
+export async function importPatzeDist<T>(relativePath: string): Promise<T> {
+  const modulePath = resolve(resolvePatzePackageRoot(), "dist", relativePath)
+  return import(pathToFileURL(modulePath).href) as Promise<T>
+}

package/opentui/src/transcript-render.ts

@@ -0,0 +1,218 @@
+export type TranscriptEntryKind =
+  | "assistant"
+  | "error"
+  | "meta"
+  | "status"
+  | "tool"
+  | "user"
+
+export type TranscriptEntry = {
+  id: string
+  kind: TranscriptEntryKind
+  label: string
+  text: string
+  upsertKey?: string
+}
+
+export type TranscriptPart = {
+  text: string
+  bold?: boolean
+  color?: "blue" | "cyan" | "gray" | "green" | "magenta" | "red" | "white" | "yellow"
+  dimColor?: boolean
+}
+
+export type TranscriptLine = {
+  id: string
+  kind: TranscriptEntryKind
+  label: string
+  parts: TranscriptPart[]
+}
+
+export function buildTranscriptLines(entries: TranscriptEntry[], columns: number): TranscriptLine[] {
+  const labelWidth = 7
+  const textWidth = Math.max(20, columns - labelWidth - 4)
+
+  return entries.flatMap((entry) => {
+    const renderedLines = trimTrailingBlankLines(
+      entry.kind === "assistant"
+        ? renderMarkdownLines(entry.text || "...", textWidth)
+        : wrapText(entry.text || "...", textWidth).map((text) => ({
+            parts: [{ text }],
+          }))
+    )
+
+    return renderedLines.map((line, index) => ({
+      id: `${entry.id}-${index}`,
+      kind: entry.kind,
+      label: index === 0 ? entry.label : "",
+      parts: line.parts,
+    }))
+  })
+}
+
+function trimTrailingBlankLines(lines: Array<{ parts: TranscriptPart[] }>) {
+  let end = lines.length
+
+  while (end > 1 && isBlankRenderedLine(lines[end - 1])) {
+    end -= 1
+  }
+
+  return lines.slice(0, end)
+}
+
+function isBlankRenderedLine(line: { parts: TranscriptPart[] }) {
+  return line.parts.every((part) => part.text.trim() === "")
+}
+
+function renderMarkdownLines(value: string, width: number) {
+  const lines: Array<{ parts: TranscriptPart[] }> = []
+  let inCodeBlock = false
+
+  for (const rawLine of value.split("\n")) {
+    const line = rawLine.trimEnd()
+    const fence = line.match(/^```\s*(.*)$/)
+
+    if (fence) {
+      inCodeBlock = !inCodeBlock
+      const language = fence[1]?.trim()
+      lines.push({
+        parts: [
+          {
+            text: inCodeBlock
+              ? `--- code${language ? `: ${language}` : ""}`
+              : "--- end code",
+            color: "gray",
+            dimColor: true,
+          },
+        ],
+      })
+      continue
+    }
+
+    if (inCodeBlock) {
+      for (const text of wrapText(line || " ", width - 2)) {
+        lines.push({
+          parts: [{ text: `| ${text}`, color: "gray" }],
+        })
+      }
+      continue
+    }
+
+    const heading = line.match(/^(#{1,6})\s+(.+)$/)
+    if (heading) {
+      for (const text of wrapText(heading[2] ?? "", width - 2)) {
+        lines.push({
+          parts: [{ text: `# ${text}`, bold: true, color: "cyan" }],
+        })
+      }
+      continue
+    }
+
+    const blockquote = line.match(/^>\s?(.*)$/)
+    if (blockquote) {
+      for (const text of wrapText(blockquote[1] || " ", width - 2)) {
+        lines.push({
+          parts: [
+            { text: "> ", color: "gray", dimColor: true },
+            ...parseInlineMarkdown(text),
+          ],
+        })
+      }
+      continue
+    }
+
+    const unordered = line.match(/^\s*[-*+]\s+(.+)$/)
+    if (unordered) {
+      for (const [index, text] of wrapText(unordered[1] ?? "", width - 2).entries()) {
+        lines.push({
+          parts: [
+            { text: index === 0 ? "- " : "  ", color: "cyan" },
+            ...parseInlineMarkdown(text),
+          ],
+        })
+      }
+      continue
+    }
+
+    const ordered = line.match(/^\s*(\d+)[.)]\s+(.+)$/)
+    if (ordered) {
+      const marker = `${ordered[1]}. `
+      for (const [index, text] of wrapText(ordered[2] ?? "", width - marker.length).entries()) {
+        lines.push({
+          parts: [
+            { text: index === 0 ? marker : " ".repeat(marker.length), color: "cyan" },
+            ...parseInlineMarkdown(text),
+          ],
+        })
+      }
+      continue
+    }
+
+    for (const text of wrapText(line, width)) {
+      lines.push({ parts: parseInlineMarkdown(text) })
+    }
+  }
+
+  return lines
+}
+
+function wrapText(value: string, width: number) {
+  const lines: string[] = []
+
+  for (const rawLine of value.split("\n")) {
+    let line = rawLine
+
+    if (!line) {
+      lines.push("")
+      continue
+    }
+
+    while (line.length > width) {
+      let breakAt = line.lastIndexOf(" ", width)
+      if (breakAt < width * 0.5) {
+        breakAt = width
+      }
+
+      lines.push(line.slice(0, breakAt).trimEnd())
+      line = line.slice(breakAt).trimStart()
+    }
+
+    lines.push(line)
+  }
+
+  return lines
+}
+
+function parseInlineMarkdown(value: string): TranscriptPart[] {
+  const parts: TranscriptPart[] = []
+  const pattern = /(\*\*[^*]+\*\*|`[^`]+`|\*[^*]+\*)/g
+  let lastIndex = 0
+  let match: RegExpExecArray | null
+
+  while ((match = pattern.exec(value)) !== null) {
+    if (match.index > lastIndex) {
+      parts.push({ text: value.slice(lastIndex, match.index) })
+    }
+
+    const token = match[0]
+    if (token.startsWith("**")) {
+      parts.push({ text: token.slice(2, -2), bold: true })
+    } else if (token.startsWith("`")) {
+      parts.push({ text: token.slice(1, -1), color: "magenta" })
+    } else {
+      parts.push({ text: token.slice(1, -1), bold: true, color: "cyan" })
+    }
+
+    lastIndex = match.index + token.length
+  }
+
+  if (lastIndex < value.length) {
+    parts.push({ text: value.slice(lastIndex) })
+  }
+
+  if (!parts.length) {
+    parts.push({ text: value })
+  }
+
+  return parts
+}

package/opentui/src/tui-sink.ts

@@ -0,0 +1,78 @@
+import type { TranscriptEntry, TranscriptEntryKind } from "./transcript-render.js"
+import { deriveTranscriptUpsertKey } from "../../dist/cli/interactive/transcript-upsert.js"
+
+type TextWriter = {
+  line: (text?: string) => void
+}
+import { parseTranscriptLine } from "./line-parse.js"
+
+export type TranscriptSinkCallbacks = {
+  addEntry: (entry: Omit<TranscriptEntry, "id"> & { upsertKey?: string }) => void
+  upsertEntry: (upsertKey: string, entry: Omit<TranscriptEntry, "id">) => void
+  appendToLast: (text: string) => void
+  upsertStreaming: (text: string) => void
+  clearStreaming: () => void
+}
+
+export function createTranscriptSink(callbacks: TranscriptSinkCallbacks): TextWriter {
+  return {
+    line(text = "") {
+      callbacks.clearStreaming()
+      const parsed = parseTranscriptLine(text)
+      if (!parsed) {
+        return
+      }
+
+      if (parsed.continuation) {
+        callbacks.appendToLast(parsed.text)
+        return
+      }
+
+      const entry = {
+        kind: parsed.kind,
+        label: parsed.label,
+        text: parsed.text,
+      }
+      const upsertKey = deriveTranscriptUpsertKey(parsed.kind, parsed.label, parsed.text)
+      if (upsertKey) {
+        callbacks.upsertEntry(upsertKey, entry)
+        return
+      }
+
+      callbacks.addEntry(entry)
+    },
+  }
+}
+
+export function classifyPlainOutput(lines: string[]): Array<Omit<TranscriptEntry, "id">> {
+  const entries: Array<Omit<TranscriptEntry, "id">> = []
+
+  for (const raw of lines) {
+    const parsed = parseTranscriptLine(raw)
+    if (!parsed) {
+      continue
+    }
+
+    if (parsed.continuation && entries.length > 0) {
+      const last = entries[entries.length - 1]
+      last.text = `${last.text}\n${parsed.text}`
+      continue
+    }
+
+    entries.push({
+      kind: parsed.kind,
+      label: parsed.label,
+      text: parsed.text,
+    })
+  }
+
+  return entries
+}
+
+export function inferErrorKind(text: string): TranscriptEntryKind {
+  const lower = text.toLowerCase()
+  if (lower.includes("error") || lower.includes("failed") || lower.includes("unknown command")) {
+    return "error"
+  }
+  return "status"
+}

package/opentui/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "jsxImportSource": "@opentui/react",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patze/code-cli",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "Patze Code — local terminal coding agent client for PatzeAgents",
   "license": "UNLICENSED",
   "type": "module",
@@ -17,7 +17,11 @@
     "CHANGELOG.md",
     "NOTICE.md",
     "README.md",
-    "VERSION"
+    "VERSION",
+    "opentui/package.json",
+    "opentui/tsconfig.json",
+    "opentui/scripts",
+    "opentui/src"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",