termcast 1.3.47 → 1.3.49

package/src/logger.tsx

@@ -1,5 +1,6 @@
 import * as fs from 'fs'
 import * as path from 'path'
+import util from 'node:util'
 import { useEffect } from 'react'
 
 const LOG_FILE = path.join(process.cwd(), 'app.log')
@@ -16,7 +17,7 @@ function serialize(msg: any): string {
   if (typeof msg === 'string') {
     return msg
   }
-  return Bun.inspect(msg, { depth: 3 })
+  return util.inspect(msg, { depth: 3 })
 }
 
 export const logger = {

package/src/markdown-utils.tsx

@@ -18,9 +18,12 @@ import {
   createTextAttributes,
   type Renderable,
   type RenderContext,
+  type SyntaxStyle,
 } from '@opentui/core'
+import { Lexer } from 'marked'
 import { getResolvedTheme } from './themes'
 import { useStore } from './state'
+import { TableRenderable, type TableCellContent } from 'termcast/src/components/table'
 
 // Minimal token types from marked (dependency of opentui, not termcast directly)
 interface Token {
@@ -29,10 +32,19 @@ interface Token {
   raw?: string
   href?: string
   tokens?: Token[]
+  // Table-specific fields (from marked Tokens.Table)
+  header?: TableCell[]
+  rows?: TableCell[][]
+}
+
+interface TableCell {
+  text: string
+  tokens: Token[]
 }
 
 // Matches RenderNodeContext from @opentui/core/renderables/Markdown
 interface RenderNodeContext {
+  syntaxStyle: SyntaxStyle
   defaultRender: () => Renderable | null
 }
 
@@ -53,7 +65,9 @@ function hasLinks(token: Token): boolean {
 
 // Recursively flatten inline tokens into chunks, stripping link URLs.
 // Handles nested structures like **[link](url)** or *[link](url)*.
-function flattenInlineTokens({
+// Exported so the standalone <Table> component can reuse this for
+// parsing inline markdown in cell strings.
+export function flattenInlineTokens({
   tokens,
   chunks,
   links,
@@ -150,6 +164,51 @@ export function createMarkdownRenderNode(renderer: RenderContext): (token: Token
   let nodeCounter = 0
 
   return (token: Token, context: RenderNodeContext) => {
+    // Override table tokens with our custom borderless TableRenderable
+    // (header background + alternating row stripes instead of ASCII borders).
+    // Converts inline markdown tokens (bold, italic, code, links) into
+    // StyledText so formatting is preserved in table cells.
+    if (token.type === 'table' && token.header && token.rows) {
+      const themeName = useStore.getState().currentThemeName
+      const theme = getResolvedTheme(themeName)
+      const primaryColor = parseColor(theme.primary)
+      const linkColor = parseColor(theme.markdownLinkText)
+      const textColor = parseColor(theme.text)
+
+      const cellToStyledText = (tokens: Token[] | undefined): TableCellContent => {
+        if (!tokens || tokens.length === 0) {
+          return new StyledText([{ __isChunk: true, text: ' ', fg: textColor }])
+        }
+        const chunks: TextChunk[] = []
+        const links: LinkInfo[] = []
+        flattenInlineTokens({ tokens, chunks, links, primaryColor, linkColor, textColor })
+        if (chunks.length === 0) {
+          return new StyledText([{ __isChunk: true, text: ' ', fg: textColor }])
+        }
+        return new StyledText(chunks)
+      }
+
+      const headers = token.header.map((cell) => {
+        return cellToStyledText(cell.tokens)
+      })
+      const rows = token.rows.map((row) => {
+        return row.map((cell) => {
+          return cellToStyledText(cell.tokens)
+        })
+      })
+      if (headers.length === 0 || rows.length === 0) {
+        return undefined
+      }
+      return new TableRenderable(renderer, {
+        id: `table-${nodeCounter++}`,
+        headers,
+        rows,
+        syntaxStyle: context.syntaxStyle,
+        width: '100%',
+        marginBottom: 1,
+      })
+    }
+
     // Only override paragraphs that contain links (including nested)
     if (token.type !== 'paragraph' || !hasLinks(token)) {
       return undefined // use default rendering
@@ -180,3 +239,25 @@ export function createMarkdownRenderNode(renderer: RenderContext): (token: Token
     })
   }
 }
+
+// Parse a raw string containing inline markdown (bold, italic, code,
+// links, strikethrough) into a StyledText. Uses marked's inline lexer
+// to tokenize, then flattenInlineTokens to produce styled chunks.
+// If the string contains no markdown syntax, returns a plain StyledText.
+export function parseInlineMarkdown(text: string): StyledText {
+  const themeName = useStore.getState().currentThemeName
+  const theme = getResolvedTheme(themeName)
+  const primaryColor = parseColor(theme.primary)
+  const linkColor = parseColor(theme.markdownLinkText)
+  const textColor = parseColor(theme.text)
+
+  const tokens = new Lexer().inlineTokens(text) as Token[]
+  const chunks: TextChunk[] = []
+  const links: LinkInfo[] = []
+  flattenInlineTokens({ tokens, chunks, links, primaryColor, linkColor, textColor })
+
+  if (chunks.length === 0) {
+    return new StyledText([{ __isChunk: true, text: ' ', fg: textColor }])
+  }
+  return new StyledText(chunks)
+}

package/src/opentui.tsx

@@ -0,0 +1,5 @@
+export * from '@opentui/core'
+export * from '@opentui/react'
+// Disambiguate names exported by both core and react (type-only to avoid
+// runtime errors when the JS bundle doesn't actually export the name)
+export type { RenderableConstructor } from '@opentui/core'

package/src/release.tsx

@@ -15,6 +15,7 @@ import {
 export interface ReleaseOptions {
   extensionPath: string
   single?: boolean
+  entry?: string
 }
 
 export interface ReleaseResult {
@@ -27,6 +28,7 @@ export interface ReleaseResult {
 export async function releaseExtension({
   extensionPath,
   single = false,
+  entry,
 }: ReleaseOptions): Promise<ReleaseResult> {
   const resolvedPath = path.resolve(extensionPath)
 
@@ -127,6 +129,7 @@ export async function releaseExtension({
         minify: true,
         target,
         version: tag,
+        entry,
       })
 
       console.log(`  ✓ ${path.basename(result.outfile)}`)

package/src/state.tsx

@@ -45,6 +45,7 @@ export interface NavigationStackItem {
   element: ReactNode
   onPop?: () => void
   selectedListIndex?: number
+  searchText?: string
 }
 
 interface AppState {
@@ -109,7 +110,7 @@ export const useStore = create<AppState>(() => ({
   showActionsDialog: false,
   actionsPortalTarget: null,
   // Theme state
-  currentThemeName: 'termcast',
+  currentThemeName: 'nerv',
   // Active search input ref
   activeSearchInputRef: null,
   // Registered action shortcuts

package/src/swift-runtime.tsx

@@ -1,3 +1,4 @@
+import childProcess from 'node:child_process'
 import { logger } from './logger'
 
 export async function runSwiftFunction(
@@ -9,14 +10,27 @@ export async function runSwiftFunction(
 
   logger.log(`Swift: calling ${functionName} with args:`, jsonArgs)
 
-  const proc = Bun.spawn([binaryPath, functionName, ...jsonArgs], {
-    stdout: 'pipe',
-    stderr: 'inherit',
+  const proc = childProcess.spawn(binaryPath, [functionName, ...jsonArgs], {
+    stdio: ['ignore', 'pipe', 'inherit'],
   })
 
   const [stdout, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    proc.exited,
+    new Promise<string>((resolve, reject) => {
+      const chunks: Buffer[] = []
+      proc.stdout!.on('data', (chunk) => { chunks.push(chunk) })
+      proc.stdout!.on('error', reject)
+      proc.stdout!.on('end', () => { resolve(Buffer.concat(chunks).toString()) })
+    }),
+    new Promise<number | null>((resolve, reject) => {
+      proc.on('error', reject)
+      proc.on('close', (code, signal) => {
+        if (signal) {
+          reject(new Error(`Swift function "${functionName}" was killed by signal ${signal}`))
+        } else {
+          resolve(code)
+        }
+      })
+    }),
   ])
 
   if (exitCode !== 0) {

package/src/theme.tsx

@@ -58,6 +58,20 @@ export function getMarkdownSyntaxStyle(): SyntaxStyle {
   return SyntaxStyle.fromStyles(getSyntaxTheme(themeName))
 }
 
+// Shared color palette for all chart components (Graph, BarChart, BarGraph).
+// Order: accent, info, success, warning, error, secondary, primary (cycles with %).
+export function getThemePalette(theme: ResolvedTheme): string[] {
+  return [
+    theme.accent,
+    theme.info,
+    theme.success,
+    theme.warning,
+    theme.error,
+    theme.secondary,
+    theme.primary,
+  ]
+}
+
 // For backward compatibility - some code imports markdownSyntaxStyle directly
 // This is a getter that returns the current theme's syntax style
 export const markdownSyntaxStyle = new Proxy({} as SyntaxStyle, {

package/src/themes/nerv.json

@@ -0,0 +1,231 @@
+{
+  "$schema": "https://opencode.ai/theme.json",
+  "defs": {
+    "darkStep1": "#181818",
+    "darkStep2": "#181818",
+    "darkStep3": "#282828",
+    "darkStep4": "#333333",
+    "darkStep5": "#404040",
+    "darkStep6": "#505050",
+    "darkStep7": "#606060",
+    "darkStep8": "#808080",
+    "darkStep11": "#999999",
+    "darkStep12": "#FFFFFF",
+
+    "darkOrange": "#E89500",
+    "darkOrangeBright": "#FFAA15",
+    "darkOrangeDim": "#C07800",
+    "darkOrangeDeep": "#A05C00",
+    "darkOrangeWash": "#FFBB50",
+
+    "darkGreen": "#2BBD50",
+    "darkGreenBright": "#44DD66",
+    "darkGreenDim": "#1F9940",
+    "darkGreenDeep": "#167030",
+
+    "darkSalmon": "#F7768E"
+  },
+
+  "theme": {
+    "primary": {
+      "dark": "darkOrange",
+      "light": "darkOrange"
+    },
+    "secondary": {
+      "dark": "darkOrangeDim",
+      "light": "darkOrangeDim"
+    },
+    "accent": {
+      "dark": "darkOrangeBright",
+      "light": "darkOrangeBright"
+    },
+    "error": {
+      "dark": "darkSalmon",
+      "light": "darkSalmon"
+    },
+    "warning": {
+      "dark": "darkOrangeWash",
+      "light": "darkOrangeWash"
+    },
+    "success": {
+      "dark": "darkGreen",
+      "light": "darkGreen"
+    },
+    "info": {
+      "dark": "darkGreenBright",
+      "light": "darkGreenBright"
+    },
+    "text": {
+      "dark": "darkStep12",
+      "light": "darkStep12"
+    },
+    "textMuted": {
+      "dark": "darkStep11",
+      "light": "darkStep11"
+    },
+    "background": {
+      "dark": "darkStep1",
+      "light": "darkStep1"
+    },
+    "backgroundPanel": {
+      "dark": "darkStep2",
+      "light": "darkStep2"
+    },
+    "backgroundElement": {
+      "dark": "darkStep3",
+      "light": "darkStep3"
+    },
+    "border": {
+      "dark": "darkStep4",
+      "light": "darkStep4"
+    },
+    "borderActive": {
+      "dark": "darkOrange",
+      "light": "darkOrange"
+    },
+    "borderSubtle": {
+      "dark": "#252525",
+      "light": "#252525"
+    },
+    "diffAdded": {
+      "dark": "darkGreen",
+      "light": "darkGreen"
+    },
+    "diffRemoved": {
+      "dark": "darkSalmon",
+      "light": "darkSalmon"
+    },
+    "diffContext": {
+      "dark": "darkStep11",
+      "light": "darkStep11"
+    },
+    "diffHunkHeader": {
+      "dark": "darkStep11",
+      "light": "darkStep11"
+    },
+    "diffHighlightAdded": {
+      "dark": "darkGreenBright",
+      "light": "darkGreenBright"
+    },
+    "diffHighlightRemoved": {
+      "dark": "darkSalmon",
+      "light": "darkSalmon"
+    },
+    "diffAddedBg": {
+      "dark": "#1A2B1E",
+      "light": "#1A2B1E"
+    },
+    "diffRemovedBg": {
+      "dark": "#37222c",
+      "light": "#37222c"
+    },
+    "diffContextBg": {
+      "dark": "darkStep2",
+      "light": "darkStep2"
+    },
+    "diffLineNumber": {
+      "dark": "darkStep4",
+      "light": "darkStep4"
+    },
+    "diffAddedLineNumberBg": {
+      "dark": "#162518",
+      "light": "#162518"
+    },
+    "diffRemovedLineNumberBg": {
+      "dark": "#2d1f26",
+      "light": "#2d1f26"
+    },
+    "markdownText": {
+      "dark": "darkStep12",
+      "light": "darkStep12"
+    },
+    "markdownHeading": {
+      "dark": "darkOrange",
+      "light": "darkOrange"
+    },
+    "markdownLink": {
+      "dark": "darkGreen",
+      "light": "darkGreen"
+    },
+    "markdownLinkText": {
+      "dark": "darkGreen",
+      "light": "darkGreen"
+    },
+    "markdownCode": {
+      "dark": "darkGreenDim",
+      "light": "darkGreenDim"
+    },
+    "markdownBlockQuote": {
+      "dark": "darkStep11",
+      "light": "darkStep11"
+    },
+    "markdownEmph": {
+      "dark": "darkOrangeWash",
+      "light": "darkOrangeWash"
+    },
+    "markdownStrong": {
+      "dark": "darkOrangeBright",
+      "light": "darkOrangeBright"
+    },
+    "markdownHorizontalRule": {
+      "dark": "darkStep11",
+      "light": "darkStep11"
+    },
+    "markdownListItem": {
+      "dark": "darkOrange",
+      "light": "darkOrange"
+    },
+    "markdownListEnumeration": {
+      "dark": "darkOrange",
+      "light": "darkOrange"
+    },
+    "markdownImage": {
+      "dark": "darkOrange",
+      "light": "darkOrange"
+    },
+    "markdownImageText": {
+      "dark": "darkGreen",
+      "light": "darkGreen"
+    },
+    "markdownCodeBlock": {
+      "dark": "darkStep12",
+      "light": "darkStep12"
+    },
+    "syntaxComment": {
+      "dark": "darkStep11",
+      "light": "darkStep11"
+    },
+    "syntaxKeyword": {
+      "dark": "darkOrange",
+      "light": "darkOrange"
+    },
+    "syntaxFunction": {
+      "dark": "darkOrangeBright",
+      "light": "darkOrangeBright"
+    },
+    "syntaxVariable": {
+      "dark": "darkSalmon",
+      "light": "darkSalmon"
+    },
+    "syntaxString": {
+      "dark": "darkGreenDim",
+      "light": "darkGreenDim"
+    },
+    "syntaxNumber": {
+      "dark": "darkOrangeWash",
+      "light": "darkOrangeWash"
+    },
+    "syntaxType": {
+      "dark": "darkGreenBright",
+      "light": "darkGreenBright"
+    },
+    "syntaxOperator": {
+      "dark": "darkGreen",
+      "light": "darkGreen"
+    },
+    "syntaxPunctuation": {
+      "dark": "darkStep12",
+      "light": "darkStep12"
+    }
+  }
+}