termcast 1.3.48 → 1.3.50

package/src/cli.tsx

@@ -23,54 +23,6 @@ import packageJson from '../package.json'
 
 const cli = goke('termcast')
 
-// Auto-update check
-async function checkForUpdates() {
-  try {
-    const currentVersion = packageJson.version
-
-    // Fetch latest release info from GitHub
-    const response = await fetch(
-      'https://api.github.com/repos/remorses/termcast/releases/latest',
-    )
-    if (!response.ok) {
-      return
-    }
-
-    const latestRelease = (await response.json()) as { tag_name?: string }
-    const latestVersion =
-      latestRelease.tag_name?.replace('termcast@', '') ||
-      latestRelease.tag_name?.replace('v', '')
-
-    // Compare versions
-    if (latestVersion && latestVersion !== currentVersion) {
-      // Run the install script in background
-      const updateProcess = spawn(
-        'bash',
-        ['-c', 'curl -sf https://termcast.app/install | bash'],
-        {
-          detached: true,
-          stdio: 'ignore',
-        },
-      )
-
-      updateProcess.on('exit', async (code) => {
-        if (code === 0) {
-          // Show toast notification only on successful completion
-          await showToast({
-            title: 'Update available',
-            message: `Restart to use the new version ${latestVersion}`,
-            style: Toast.Style.Success,
-          })
-        }
-      })
-
-      // updateProcess.unref()
-    }
-  } catch (error) {
-    // Silently fail - don't interrupt the user's workflow
-    logger.log('Failed to check for updates:', error)
-  }
-}
 
 // TODO: re-enable auto-update check once install script temp dir issue is fixed
 // checkForUpdates()
@@ -259,6 +211,7 @@ cli
   .command('compile [path]', 'Compile the extension to a standalone executable')
   .option('-o, --outfile <path>', 'Output file path for the executable')
   .option('--minify', 'Minify the output')
+  .option('--entry <file>', 'Custom entry file (instead of auto-generated one)')
   .action(async (extensionPath, options) => {
     extensionPath = path.resolve(extensionPath || process.cwd())
 
@@ -268,6 +221,7 @@ cli
         extensionPath,
         outfile: options.outfile,
         minify: options.minify,
+        entry: options.entry,
       })
 
       console.log(`\nExecutable created: ${result.outfile}`)
@@ -282,7 +236,8 @@ cli
 cli
   .command('release [path]', 'Build and publish extension to GitHub releases')
   .option('--single', 'Only compile for the current platform')
-  .action(async (extensionPath: string, options: { single?: boolean }) => {
+  .option('--entry <file>', 'Custom entry file (instead of auto-generated one)')
+  .action(async (extensionPath: string, options: { single?: boolean; entry?: string }) => {
     extensionPath = path.resolve(extensionPath || process.cwd())
 
     console.log('Building and releasing extension...')
@@ -290,6 +245,7 @@ cli
       const result = await releaseExtension({
         extensionPath,
         single: options.single,
+        entry: options.entry,
       })
 
       console.log(`\nRelease complete: ${result.tag}`)

package/src/colors.tsx

@@ -1,11 +1,11 @@
 export enum Color {
-  Blue = '#0080FF',
-  Green = '#00FF80',
-  Magenta = '#FF00FF',
-  Orange = '#FF8000',
-  Purple = '#8000FF',
-  Red = '#FF0000',
-  Yellow = '#FFFF00',
+  Blue = '#5CB8FF',
+  Green = '#34EE7F',
+  Magenta = '#F07FFF',
+  Orange = '#FF9F43',
+  Purple = '#BF8FFF',
+  Red = '#FF7B7B',
+  Yellow = '#FFD534',
   PrimaryText = '#FFFFFF',
   SecondaryText = '#999999',
 }

package/src/compile.tsx

@@ -5,29 +5,26 @@ import { logger } from './logger'
 import { getCommandsWithFiles } from './package-json'
 import { swiftLoaderPlugin } from './swift-loader'
 
+// compile.tsx lives at termcast/src/compile.tsx, so __dirname is termcast/src/
+const termcastRoot = path.resolve(__dirname, '..')
+
 const raycastAliasPlugin: BunPlugin = {
   name: 'raycast-to-termcast',
   setup(build) {
     build.onResolve({ filter: /@raycast\/api/ }, () => ({
-      path: require.resolve('termcast/src/index'),
+      path: path.join(__dirname, 'index.tsx'),
     }))
-
     build.onResolve({ filter: /@raycast\/utils/ }, () => ({
       path: require.resolve('@termcast/utils'),
     }))
-
+    // termcast and termcast/* — resolve directly from the package source
     build.onResolve({ filter: /^termcast/ }, (args) => ({
-      path: require.resolve(args.path),
+      path: args.path === 'termcast'
+        ? path.join(__dirname, 'index.tsx')
+        : require.resolve(args.path, { paths: [termcastRoot] }),
     }))
-
-    build.onResolve({ filter: /^react$/ }, () => ({
-      path: require.resolve('react'),
-    }))
-    build.onResolve({ filter: /^react\/jsx-runtime$/ }, () => ({
-      path: require.resolve('react/jsx-runtime'),
-    }))
-    build.onResolve({ filter: /^react\/jsx-dev-runtime$/ }, () => ({
-      path: require.resolve('react/jsx-dev-runtime'),
+    build.onResolve({ filter: /^react(\/|$)/ }, (args) => ({
+      path: require.resolve(args.path),
     }))
   },
 }
@@ -153,6 +150,11 @@ export interface CompileOptions {
   minify?: boolean
   target?: CompileTarget
   version?: string
+  /** Custom entry file. When set, this file is used as the entrypoint instead of
+   *  the auto-generated one. Useful for CLIs that have their own subcommands and
+   *  only launch termcast for one of them (e.g. a "tui" subcommand). The same
+   *  raycast alias plugin and swift loader plugin are still applied. */
+  entry?: string
 }
 
 export interface CompileResult {
@@ -166,6 +168,7 @@ export async function compileExtension({
   minify = false,
   target,
   version,
+  entry,
 }: CompileOptions): Promise<CompileResult> {
   const resolvedPath = path.resolve(extensionPath)
 
@@ -178,28 +181,35 @@ export async function compileExtension({
     throw new Error(`No package.json found at: ${packageJsonPath}`)
   }
 
+  // When using a custom entry, commands are optional — the user manages their own entry
   const { packageJson, commands } = getCommandsWithFiles({ packageJsonPath })
 
-  const existingCommands = commands.filter((cmd) => cmd.exists)
-  if (existingCommands.length === 0) {
-    throw new Error('No command files found to build')
+  if (!entry) {
+    const existingCommands = commands.filter((cmd) => cmd.exists)
+    if (existingCommands.length === 0) {
+      throw new Error('No command files found to build')
+    }
+    logger.log(`Compiling ${existingCommands.length} commands...`)
+  } else {
+    logger.log(`Compiling with custom entry: ${entry}`)
   }
 
-  logger.log(`Compiling ${existingCommands.length} commands...`)
-
   const bundleDir = path.join(resolvedPath, '.termcast-bundle')
   if (!fs.existsSync(bundleDir)) {
     fs.mkdirSync(bundleDir, { recursive: true })
   }
   fs.writeFileSync(path.join(bundleDir, '.gitignore'), '*\n')
 
-  const entryCode = generateEntryCode({
-    packageJson,
-    commands: existingCommands.map((cmd) => ({
-      name: cmd.name,
-      bundledPath: cmd.filePath,
-    })),
-  })
+  const existingCommands = commands.filter((cmd) => cmd.exists)
+  const entryCode = entry
+    ? undefined
+    : generateEntryCode({
+        packageJson,
+        commands: existingCommands.map((cmd) => ({
+          name: cmd.name,
+          bundledPath: cmd.filePath,
+        })),
+      })
 
   // IMPORTANT: always compile with a concrete target (bun-linux-x64, bun-darwin-arm64, ...)
   // rather than the generic "bun" target. Using the generic target can cause Bun.build to
@@ -207,9 +217,22 @@ export async function compileExtension({
   // (e.g. @opentui/core-linux-musl-x64) even when compiling/running on glibc Linux.
   const resolvedTarget: CompileTarget = target || getCurrentTarget()
 
+  // When using a custom entry, resolve it relative to extensionPath and use directly.
+  // Otherwise generate a temp entry file with embedded packageJson and command loaders.
+  const resolvedEntry = entry ? path.resolve(resolvedPath, entry) : undefined
+  if (resolvedEntry && !fs.existsSync(resolvedEntry)) {
+    throw new Error(`Custom entry file does not exist: ${resolvedEntry}`)
+  }
+
   const targetSuffix = target ? targetToFileSuffix(target) : 'local'
-  const tempEntryPath = path.join(bundleDir, `_entry-${targetSuffix}.tsx`)
-  fs.writeFileSync(tempEntryPath, entryCode)
+  const tempEntryPath = resolvedEntry
+    ? undefined
+    : path.join(bundleDir, `_entry-${targetSuffix}.tsx`)
+  if (tempEntryPath && entryCode) {
+    fs.writeFileSync(tempEntryPath, entryCode)
+  }
+
+  const entrypoint = resolvedEntry || tempEntryPath!
 
   const bunTarget = targetToString(resolvedTarget)
   const distDir = path.join(resolvedPath, 'dist')
@@ -221,7 +244,7 @@ export async function compileExtension({
 
   try {
     const result = await Bun.build({
-      entrypoints: [tempEntryPath],
+      entrypoints: [entrypoint],
       target: bunTarget as 'bun',
       format: 'esm',
       minify,
@@ -281,7 +304,7 @@ export async function compileExtension({
       outfile: defaultOutfile,
     }
   } finally {
-    if (fs.existsSync(tempEntryPath)) {
+    if (tempEntryPath && fs.existsSync(tempEntryPath)) {
       fs.unlinkSync(tempEntryPath)
     }
   }

package/src/components/actions.tsx

@@ -914,7 +914,7 @@ const ActionPanel: ActionPanelType = (props) => {
           }}
         />
         <Action
-          title="See Console Logs"
+          title="Toggle Console Logs"
           onAction={() => {
             useStore.setState({ showActionsDialog: false })
             if (renderer) {

package/src/components/bar-chart.tsx

@@ -0,0 +1,271 @@
+/**
+ * BarChart component for rendering horizontal stacked bar charts in the terminal.
+ *
+ * Uses opentui <box> elements with backgroundColor for each segment, sized
+ * proportionally via flexGrow. Labels are positioned above or below the bar
+ * with corner bracket connectors (┌/┐/└/┘).
+ *
+ * Segments too small to display (< 1 terminal column) are hidden.
+ * Labels are hidden when the segment is narrower than the label text.
+ *
+ * Color palette (assigned by value descending):
+ *   primary, accent, info, success, warning, error, secondary (cycles with %)
+ */
+
+import React, { ReactNode, useMemo } from 'react'
+import { useTheme, getThemePalette } from 'termcast/src/theme'
+import { Color, resolveColor } from 'termcast/src/colors'
+
+// ── Types ────────────────────────────────────────────────────────────
+
+export interface BarChartSegmentProps {
+  /** Numeric value for this segment (determines proportional width) */
+  value: number
+  /** Label text shown above/below the segment (e.g. "Spent") */
+  label?: string
+  /** Override the auto-assigned color */
+  color?: Color.ColorLike
+}
+
+export interface BarChartProps {
+  /** Height of the colored bar in terminal rows (default: 1) */
+  height?: number
+  /** Show label annotations above/below the bar (default: true) */
+  showLabels?: boolean
+  /** BarChart.Segment children */
+  children: ReactNode
+}
+
+interface BarChartType {
+  (props: BarChartProps): any
+  Segment: (props: BarChartSegmentProps) => any
+}
+
+// ── Internal: collected segment data ─────────────────────────────────
+
+interface SegmentData {
+  value: number
+  label?: string
+  color?: string // resolved hex, or undefined for auto
+  /** Index in original children order */
+  originalIndex: number
+}
+
+// ── BarChart.Segment (data-only, renders null like Graph.Line) ───────
+
+const BarChartSegment = (_props: BarChartSegmentProps): any => {
+  return null
+}
+
+// ── Label positioning ────────────────────────────────────────────────
+// Labels use the same flexGrow as segments so they naturally align.
+// "above" labels: fit within segment width. "below": overflow-hidden.
+// The decision is based on estimated proportional width vs text length.
+
+interface PositionedLabel {
+  text: string
+  segmentIndex: number
+  position: 'above' | 'below'
+}
+
+function formatValue(value: number, total: number): string {
+  const pct = (value / total) * 100
+  if (pct >= 1) {
+    return pct % 1 === 0 ? `${pct.toFixed(0)}%` : `${pct.toFixed(1)}%`
+  }
+  return `${pct.toFixed(1)}%`
+}
+
+function buildLabelText(label: string | undefined, value: number, total: number): string {
+  const formatted = formatValue(value, total)
+  if (label) {
+    return `${label}: ${formatted}`
+  }
+  return formatted
+}
+
+function computeLabels({
+  segments,
+  total,
+}: {
+  segments: SegmentData[]
+  total: number
+}): { above: PositionedLabel[]; below: PositionedLabel[] } {
+  const above: PositionedLabel[] = []
+  const below: PositionedLabel[] = []
+
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i]!
+    const text = buildLabelText(seg.label, seg.value, total)
+    const proportion = seg.value / total
+
+    // Skip labels for small segments - they'd be unreadable noise.
+    // 12% threshold ensures at least ~6 cols in a 50-col container,
+    // enough for a bracket + 4 chars + bracket.
+    if (proportion < 0.12) {
+      continue
+    }
+
+    const positioned: PositionedLabel = {
+      text,
+      segmentIndex: i,
+      position: 'above',
+    }
+
+    // Heuristic for "fits above": text + brackets (2 chars) must fit within
+    // estimated segment width. We use proportion * 60 as a conservative
+    // estimate (works for containers 50-100 cols wide).
+    const estimatedCols = proportion * 60
+    if (text.length + 2 <= estimatedCols) {
+      above.push(positioned)
+    } else if (estimatedCols >= 5) {
+      // Only show below if there's enough space for a readable truncation
+      // (bracket + at least 3 chars + bracket = 5 cols minimum)
+      positioned.position = 'below'
+      below.push(positioned)
+    }
+    // else: segment too narrow for readable label in either position, skip
+  }
+
+  return { above, below }
+}
+
+// ── Render a label row using flexbox ─────────────────────────────────
+// Each segment gets a box with the same flexGrow so labels align with the bar.
+// overflow="hidden" and wrapMode="none" ensure long labels clip rather than wrap.
+
+function LabelRow({ segments, labelMap, position, color }: {
+  segments: Array<SegmentData & { resolvedColor: string }>
+  labelMap: Map<number, PositionedLabel>
+  position: 'above' | 'below'
+  color: string
+}): any {
+  const hasAnyLabel = segments.some((_, i) => labelMap.has(i))
+  if (!hasAnyLabel) {
+    return null
+  }
+
+  const openBracket = position === 'above' ? '┌' : '└'
+  const closeBracket = position === 'above' ? '┐' : '┘'
+
+  return (
+    <box flexDirection="row" width="100%" height={1} flexShrink={0}>
+      {segments.map((seg, i) => {
+        const label = labelMap.get(i)
+        if (!label) {
+          // Empty spacer: uses flexGrow to maintain alignment but no height
+          return <box key={i} flexGrow={seg.value} flexShrink={1} flexBasis={0} />
+        }
+        return (
+          <box key={i} flexGrow={seg.value} flexShrink={1} flexBasis={0} overflow="hidden">
+            <text fg={color} wrapMode="none" flexShrink={0}>
+              {openBracket}{label.text}{closeBracket}
+            </text>
+          </box>
+        )
+      })}
+    </box>
+  )
+}
+
+// ── Main BarChart component ──────────────────────────────────────────
+
+const BarChart: BarChartType = (props) => {
+  const theme = useTheme()
+  const { height = 1, showLabels = true, children } = props
+
+  // Collect segment data from BarChart.Segment children
+  const segments = useMemo<SegmentData[]>(() => {
+    const result: SegmentData[] = []
+    let idx = 0
+    React.Children.forEach(children, (child) => {
+      if (!React.isValidElement(child)) {
+        return
+      }
+      const childProps = child.props as BarChartSegmentProps
+      if (childProps.value === undefined) {
+        return
+      }
+      result.push({
+        value: childProps.value,
+        label: childProps.label,
+        color: resolveColor(childProps.color),
+        originalIndex: idx,
+      })
+      idx++
+    })
+    return result
+  }, [children])
+
+  // Sort by value descending for color assignment, then restore original order
+  const palette = getThemePalette(theme)
+  const coloredSegments = useMemo<Array<SegmentData & { resolvedColor: string }>>(() => {
+    // Create index mapping: sort by value desc, assign colors
+    const sortedIndices = segments
+      .map((_, i) => i)
+      .sort((a, b) => segments[b]!.value - segments[a]!.value)
+
+    const colorMap = new Map<number, string>()
+    sortedIndices.forEach((origIdx, rank) => {
+      const seg = segments[origIdx]!
+      const color = seg.color || palette[rank % palette.length]!
+      colorMap.set(origIdx, color)
+    })
+
+    return segments.map((seg, i) => ({
+      ...seg,
+      resolvedColor: colorMap.get(i) || palette[0]!,
+    }))
+  }, [segments, palette])
+
+  const total = useMemo(() => {
+    return coloredSegments.reduce((sum, s) => sum + s.value, 0)
+  }, [coloredSegments])
+
+  if (total === 0 || coloredSegments.length === 0) {
+    return null
+  }
+
+  // Filter out segments too small to render (proportion < 0.5%)
+  const visibleSegments = coloredSegments.filter((seg) => {
+    const proportion = seg.value / total
+    return proportion >= 0.005
+  })
+
+  // Compute labels
+  const { above, below } = showLabels
+    ? computeLabels({ segments: visibleSegments, total })
+    : { above: [], below: [] }
+
+  // Build lookup maps: segmentIndex -> label
+  const aboveMap = new Map(above.map((l) => [l.segmentIndex, l]))
+  const belowMap = new Map(below.map((l) => [l.segmentIndex, l]))
+
+  return (
+    <box flexDirection="column" width="100%" flexShrink={0}>
+      <LabelRow
+        segments={visibleSegments}
+        labelMap={aboveMap}
+        position="above"
+        color={theme.textMuted}
+      />
+      <box flexDirection="row" height={height} width="100%" flexShrink={0}>
+        {visibleSegments.map((seg, i) => {
+          return (
+            <box key={i} flexGrow={seg.value} flexShrink={0} backgroundColor={seg.resolvedColor} height={height} />
+          )
+        })}
+      </box>
+      <LabelRow
+        segments={visibleSegments}
+        labelMap={belowMap}
+        position="below"
+        color={theme.textMuted}
+      />
+    </box>
+  )
+}
+
+BarChart.Segment = BarChartSegment
+
+export { BarChart }