@vladimirven/openswe 0.1.0

package/src/theme/themes/zenburn.json

@@ -0,0 +1,223 @@
+{
+  "$schema": "https://opencode.ai/theme.json",
+  "defs": {
+    "bg": "#3f3f3f",
+    "bgAlt": "#4f4f4f",
+    "bgPanel": "#5f5f5f",
+    "fg": "#dcdccc",
+    "fgMuted": "#9f9f9f",
+    "red": "#cc9393",
+    "redBright": "#dca3a3",
+    "green": "#7f9f7f",
+    "greenBright": "#8fb28f",
+    "yellow": "#f0dfaf",
+    "yellowDim": "#e0cf9f",
+    "blue": "#8cd0d3",
+    "blueDim": "#7cb8bb",
+    "magenta": "#dc8cc3",
+    "cyan": "#93e0e3",
+    "orange": "#dfaf8f"
+  },
+  "theme": {
+    "primary": {
+      "dark": "blue",
+      "light": "#5f7f8f"
+    },
+    "secondary": {
+      "dark": "magenta",
+      "light": "#8f5f8f"
+    },
+    "accent": {
+      "dark": "cyan",
+      "light": "#5f8f8f"
+    },
+    "error": {
+      "dark": "red",
+      "light": "#8f5f5f"
+    },
+    "warning": {
+      "dark": "yellow",
+      "light": "#8f8f5f"
+    },
+    "success": {
+      "dark": "green",
+      "light": "#5f8f5f"
+    },
+    "info": {
+      "dark": "orange",
+      "light": "#8f7f5f"
+    },
+    "text": {
+      "dark": "fg",
+      "light": "#3f3f3f"
+    },
+    "textMuted": {
+      "dark": "fgMuted",
+      "light": "#6f6f6f"
+    },
+    "background": {
+      "dark": "bg",
+      "light": "#ffffef"
+    },
+    "backgroundPanel": {
+      "dark": "bgAlt",
+      "light": "#f5f5e5"
+    },
+    "backgroundElement": {
+      "dark": "bgPanel",
+      "light": "#ebebdb"
+    },
+    "border": {
+      "dark": "#5f5f5f",
+      "light": "#d0d0c0"
+    },
+    "borderActive": {
+      "dark": "blue",
+      "light": "#5f7f8f"
+    },
+    "borderSubtle": {
+      "dark": "#4f4f4f",
+      "light": "#e0e0d0"
+    },
+    "diffAdded": {
+      "dark": "green",
+      "light": "#5f8f5f"
+    },
+    "diffRemoved": {
+      "dark": "red",
+      "light": "#8f5f5f"
+    },
+    "diffContext": {
+      "dark": "fgMuted",
+      "light": "#6f6f6f"
+    },
+    "diffHunkHeader": {
+      "dark": "cyan",
+      "light": "#5f8f8f"
+    },
+    "diffHighlightAdded": {
+      "dark": "greenBright",
+      "light": "#5f8f5f"
+    },
+    "diffHighlightRemoved": {
+      "dark": "redBright",
+      "light": "#8f5f5f"
+    },
+    "diffAddedBg": {
+      "dark": "#4f5f4f",
+      "light": "#efffef"
+    },
+    "diffRemovedBg": {
+      "dark": "#5f4f4f",
+      "light": "#ffefef"
+    },
+    "diffContextBg": {
+      "dark": "bgAlt",
+      "light": "#f5f5e5"
+    },
+    "diffLineNumber": {
+      "dark": "#6f6f6f",
+      "light": "#b0b0a0"
+    },
+    "diffAddedLineNumberBg": {
+      "dark": "#4f5f4f",
+      "light": "#efffef"
+    },
+    "diffRemovedLineNumberBg": {
+      "dark": "#5f4f4f",
+      "light": "#ffefef"
+    },
+    "markdownText": {
+      "dark": "fg",
+      "light": "#3f3f3f"
+    },
+    "markdownHeading": {
+      "dark": "yellow",
+      "light": "#8f8f5f"
+    },
+    "markdownLink": {
+      "dark": "blue",
+      "light": "#5f7f8f"
+    },
+    "markdownLinkText": {
+      "dark": "cyan",
+      "light": "#5f8f8f"
+    },
+    "markdownCode": {
+      "dark": "green",
+      "light": "#5f8f5f"
+    },
+    "markdownBlockQuote": {
+      "dark": "fgMuted",
+      "light": "#6f6f6f"
+    },
+    "markdownEmph": {
+      "dark": "yellowDim",
+      "light": "#8f8f5f"
+    },
+    "markdownStrong": {
+      "dark": "orange",
+      "light": "#8f7f5f"
+    },
+    "markdownHorizontalRule": {
+      "dark": "fgMuted",
+      "light": "#6f6f6f"
+    },
+    "markdownListItem": {
+      "dark": "blue",
+      "light": "#5f7f8f"
+    },
+    "markdownListEnumeration": {
+      "dark": "cyan",
+      "light": "#5f8f8f"
+    },
+    "markdownImage": {
+      "dark": "blue",
+      "light": "#5f7f8f"
+    },
+    "markdownImageText": {
+      "dark": "cyan",
+      "light": "#5f8f8f"
+    },
+    "markdownCodeBlock": {
+      "dark": "fg",
+      "light": "#3f3f3f"
+    },
+    "syntaxComment": {
+      "dark": "#7f9f7f",
+      "light": "#5f7f5f"
+    },
+    "syntaxKeyword": {
+      "dark": "yellow",
+      "light": "#8f8f5f"
+    },
+    "syntaxFunction": {
+      "dark": "blue",
+      "light": "#5f7f8f"
+    },
+    "syntaxVariable": {
+      "dark": "fg",
+      "light": "#3f3f3f"
+    },
+    "syntaxString": {
+      "dark": "red",
+      "light": "#8f5f5f"
+    },
+    "syntaxNumber": {
+      "dark": "greenBright",
+      "light": "#5f8f5f"
+    },
+    "syntaxType": {
+      "dark": "cyan",
+      "light": "#5f8f8f"
+    },
+    "syntaxOperator": {
+      "dark": "yellow",
+      "light": "#8f8f5f"
+    },
+    "syntaxPunctuation": {
+      "dark": "fg",
+      "light": "#3f3f3f"
+    }
+  }
+}

package/src/theme/types.ts

@@ -0,0 +1,225 @@
+/**
+ * Theme type definitions for OpenSWE
+ *
+ * Matches opencode's JSON theme schema for full compatibility
+ */
+
+// ============================================================================
+// Color Types
+// ============================================================================
+
+/** Hex color string */
+export type HexColor = `#${string}`
+
+/** Reference to a color defined in defs */
+export type RefName = string
+
+/** Dark/light mode variants */
+export interface ColorVariant {
+  dark: HexColor | RefName
+  light: HexColor | RefName
+}
+
+/** A color value can be a hex, a reference, or a variant object */
+export type ColorValue = HexColor | RefName | ColorVariant
+
+// ============================================================================
+// Theme JSON Schema
+// ============================================================================
+
+/** Core theme colors (required) */
+export interface ThemeColors {
+  primary: ColorValue
+  secondary: ColorValue
+  accent: ColorValue
+  error: ColorValue
+  warning: ColorValue
+  success: ColorValue
+  info: ColorValue
+  text: ColorValue
+  textMuted: ColorValue
+  background: ColorValue
+  backgroundPanel: ColorValue
+  backgroundElement: ColorValue
+  border: ColorValue
+  borderActive: ColorValue
+  borderSubtle: ColorValue
+}
+
+/** Extended theme colors for diff views and syntax highlighting */
+export interface ThemeColorsExtended extends ThemeColors {
+  // Diff colors
+  diffAdded?: ColorValue
+  diffRemoved?: ColorValue
+  diffContext?: ColorValue
+  diffHunkHeader?: ColorValue
+  diffHighlightAdded?: ColorValue
+  diffHighlightRemoved?: ColorValue
+  diffAddedBg?: ColorValue
+  diffRemovedBg?: ColorValue
+  diffContextBg?: ColorValue
+  diffLineNumber?: ColorValue
+  diffAddedLineNumberBg?: ColorValue
+  diffRemovedLineNumberBg?: ColorValue
+
+  // Markdown colors
+  markdownText?: ColorValue
+  markdownHeading?: ColorValue
+  markdownLink?: ColorValue
+  markdownLinkText?: ColorValue
+  markdownCode?: ColorValue
+  markdownBlockQuote?: ColorValue
+  markdownEmph?: ColorValue
+  markdownStrong?: ColorValue
+  markdownHorizontalRule?: ColorValue
+  markdownListItem?: ColorValue
+  markdownListEnumeration?: ColorValue
+  markdownImage?: ColorValue
+  markdownImageText?: ColorValue
+  markdownCodeBlock?: ColorValue
+
+  // Syntax highlighting colors
+  syntaxComment?: ColorValue
+  syntaxKeyword?: ColorValue
+  syntaxFunction?: ColorValue
+  syntaxVariable?: ColorValue
+  syntaxString?: ColorValue
+  syntaxNumber?: ColorValue
+  syntaxType?: ColorValue
+  syntaxOperator?: ColorValue
+  syntaxPunctuation?: ColorValue
+}
+
+/** JSON theme file structure */
+export interface ThemeJson {
+  $schema?: string
+  defs?: Record<string, HexColor | RefName>
+  theme: ThemeColorsExtended
+}
+
+// ============================================================================
+// Resolved Theme
+// ============================================================================
+
+/** Core resolved theme colors (all hex strings) */
+export interface ResolvedTheme {
+  // Core colors
+  primary: string
+  secondary: string
+  accent: string
+  error: string
+  warning: string
+  success: string
+  info: string
+  text: string
+  textMuted: string
+  background: string
+  backgroundPanel: string
+  backgroundElement: string
+  border: string
+  borderActive: string
+  borderSubtle: string
+
+  // Diff colors (with defaults)
+  diffAdded: string
+  diffRemoved: string
+  diffContext: string
+  diffHunkHeader: string
+  diffHighlightAdded: string
+  diffHighlightRemoved: string
+  diffAddedBg: string
+  diffRemovedBg: string
+  diffContextBg: string
+  diffLineNumber: string
+  diffAddedLineNumberBg: string
+  diffRemovedLineNumberBg: string
+
+  // Markdown colors (with defaults)
+  markdownText: string
+  markdownHeading: string
+  markdownLink: string
+  markdownLinkText: string
+  markdownCode: string
+  markdownBlockQuote: string
+  markdownEmph: string
+  markdownStrong: string
+  markdownHorizontalRule: string
+  markdownListItem: string
+  markdownListEnumeration: string
+  markdownImage: string
+  markdownImageText: string
+  markdownCodeBlock: string
+
+  // Syntax highlighting (with defaults)
+  syntaxComment: string
+  syntaxKeyword: string
+  syntaxFunction: string
+  syntaxVariable: string
+  syntaxString: string
+  syntaxNumber: string
+  syntaxType: string
+  syntaxOperator: string
+  syntaxPunctuation: string
+}
+
+/** Theme mode */
+export type ThemeMode = "dark" | "light"
+
+/** Theme name from bundled themes */
+export type BundledThemeName =
+  | "aura"
+  | "ayu"
+  | "carbonfox"
+  | "catppuccin"
+  | "catppuccin-frappe"
+  | "catppuccin-macchiato"
+  | "cobalt2"
+  | "cursor"
+  | "dracula"
+  | "everforest"
+  | "flexoki"
+  | "github"
+  | "gruvbox"
+  | "kanagawa"
+  | "lucent-orng"
+  | "material"
+  | "matrix"
+  | "mercury"
+  | "monokai"
+  | "nightowl"
+  | "nord"
+  | "one-dark"
+  | "opencode"
+  | "orng"
+  | "osaka-jade"
+  | "palenight"
+  | "rosepine"
+  | "solarized"
+  | "synthwave84"
+  | "tokyonight"
+  | "vercel"
+  | "vesper"
+  | "zenburn"
+
+// ============================================================================
+// Type Guards
+// ============================================================================
+
+/**
+ * Check if a value is a hex color string
+ */
+export function isHexColor(val: unknown): val is HexColor {
+  return typeof val === "string" && val.startsWith("#")
+}
+
+/**
+ * Check if a value is a color variant object
+ */
+export function isColorVariant(val: unknown): val is ColorVariant {
+  return (
+    typeof val === "object" &&
+    val !== null &&
+    "dark" in val &&
+    "light" in val
+  )
+}

package/src/types/sql.d.ts

@@ -0,0 +1,4 @@
+declare module "*.sql" {
+  const content: string
+  export default content
+}

package/src/utils/ansi-parser.ts

@@ -0,0 +1,225 @@
+/**
+ * ANSI SGR sequence parser
+ *
+ * Parses ANSI escape sequences and returns styled text segments
+ * for rendering in the Preview component.
+ *
+ * Handles SGR (Select Graphic Rendition) sequences for colors/styles
+ * and strips other control sequences (cursor movement, screen clearing, etc.)
+ */
+
+/**
+ * Strip non-SGR ANSI sequences from text
+ *
+ * Removes cursor movement, screen clearing, and other control sequences
+ * while preserving SGR color/style sequences (those ending with 'm')
+ */
+function stripNonSGRSequences(text: string): string {
+  // Match CSI sequences that are NOT SGR (don't end with 'm')
+  // CSI format: ESC [ <params> <final byte>
+  // SGR ends with 'm', others end with A-L, P-Z, @, etc.
+  // Also strips OSC sequences (ESC ] ... BEL/ST)
+  return text
+    // Remove CSI sequences that don't end with 'm' (cursor movement, clearing, etc.)
+    .replace(/\x1B\[[0-9;]*[A-LN-Za-ln-z@`{}|~]/g, "")
+    // Remove OSC sequences (ESC ] ... BEL or ESC ] ... ESC \)
+    .replace(/\x1B\][^\x07\x1B]*(?:\x07|\x1B\\)?/g, "")
+    // Remove other escape sequences (ESC followed by single char)
+    .replace(/\x1B[^[\]]/g, "")
+}
+
+export interface AnsiSegment {
+  text: string
+  fg?: string      // Hex color
+  bg?: string      // Hex color
+  bold?: boolean
+}
+
+// Standard 16-color palette (colors 0-15)
+const STANDARD_COLORS: Record<number, string> = {
+  0: "#000000",   // Black
+  1: "#cd0000",   // Red
+  2: "#00cd00",   // Green
+  3: "#cdcd00",   // Yellow
+  4: "#0000ee",   // Blue
+  5: "#cd00cd",   // Magenta
+  6: "#00cdcd",   // Cyan
+  7: "#e5e5e5",   // White
+  8: "#7f7f7f",   // Bright Black (Gray)
+  9: "#ff0000",   // Bright Red
+  10: "#00ff00",  // Bright Green
+  11: "#ffff00",  // Bright Yellow
+  12: "#5c5cff",  // Bright Blue
+  13: "#ff00ff",  // Bright Magenta
+  14: "#00ffff",  // Bright Cyan
+  15: "#ffffff",  // Bright White
+}
+
+/**
+ * Convert 256-color index to hex color
+ */
+function color256ToHex(n: number): string {
+  // Standard colors (0-15)
+  if (n < 16) {
+    return STANDARD_COLORS[n] ?? "#ffffff"
+  }
+
+  // Color cube (16-231): 6x6x6 cube
+  if (n < 232) {
+    const idx = n - 16
+    const r = Math.floor(idx / 36)
+    const g = Math.floor((idx % 36) / 6)
+    const b = idx % 6
+
+    const toHex = (v: number) => (v === 0 ? 0 : 55 + v * 40).toString(16).padStart(2, "0")
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`
+  }
+
+  // Grayscale (232-255): 24 shades
+  const gray = (n - 232) * 10 + 8
+  const hex = gray.toString(16).padStart(2, "0")
+  return `#${hex}${hex}${hex}`
+}
+
+/**
+ * Convert RGB values to hex color
+ */
+function rgbToHex(r: number, g: number, b: number): string {
+  const toHex = (v: number) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0")
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`
+}
+
+interface AnsiState {
+  fg?: string
+  bg?: string
+  bold: boolean
+}
+
+/**
+ * Parse SGR (Select Graphic Rendition) parameters and update state
+ */
+function parseSGR(params: number[], state: AnsiState): void {
+  let i = 0
+  while (i < params.length) {
+    const code = params[i] ?? 0
+
+    if (code === 0) {
+      // Reset all
+      state.fg = undefined
+      state.bg = undefined
+      state.bold = false
+    } else if (code === 1) {
+      // Bold on
+      state.bold = true
+    } else if (code === 22) {
+      // Bold off
+      state.bold = false
+    } else if (code >= 30 && code <= 37) {
+      // Standard foreground colors
+      state.fg = STANDARD_COLORS[code - 30]
+    } else if (code === 39) {
+      // Default foreground
+      state.fg = undefined
+    } else if (code >= 40 && code <= 47) {
+      // Standard background colors
+      state.bg = STANDARD_COLORS[code - 40]
+    } else if (code === 49) {
+      // Default background
+      state.bg = undefined
+    } else if (code >= 90 && code <= 97) {
+      // Bright foreground colors
+      state.fg = STANDARD_COLORS[code - 90 + 8]
+    } else if (code >= 100 && code <= 107) {
+      // Bright background colors
+      state.bg = STANDARD_COLORS[code - 100 + 8]
+    } else if (code === 38) {
+      // Extended foreground color
+      const nextParam = params[i + 1]
+      const colorIndex = params[i + 2]
+      if (nextParam === 5 && colorIndex !== undefined) {
+        // 256-color mode: 38;5;N
+        state.fg = color256ToHex(colorIndex)
+        i += 2
+      } else if (nextParam === 2 && params[i + 4] !== undefined) {
+        // True color mode: 38;2;R;G;B
+        state.fg = rgbToHex(params[i + 2] ?? 0, params[i + 3] ?? 0, params[i + 4] ?? 0)
+        i += 4
+      }
+    } else if (code === 48) {
+      // Extended background color
+      const nextParam = params[i + 1]
+      const colorIndex = params[i + 2]
+      if (nextParam === 5 && colorIndex !== undefined) {
+        // 256-color mode: 48;5;N
+        state.bg = color256ToHex(colorIndex)
+        i += 2
+      } else if (nextParam === 2 && params[i + 4] !== undefined) {
+        // True color mode: 48;2;R;G;B
+        state.bg = rgbToHex(params[i + 2] ?? 0, params[i + 3] ?? 0, params[i + 4] ?? 0)
+        i += 4
+      }
+    }
+    // Ignore unhandled codes
+
+    i++
+  }
+}
+
+/**
+ * Parse a line containing ANSI escape sequences into styled segments
+ */
+export function parseAnsiLine(line: string): AnsiSegment[] {
+  const segments: AnsiSegment[] = []
+  const state: AnsiState = { bold: false }
+
+  // First strip non-SGR sequences (cursor movement, etc.) that would cause garbling
+  const cleanedLine = stripNonSGRSequences(line)
+
+  // Match ANSI SGR sequences: ESC [ params m
+  const regex = /\x1B\[([0-9;]*)m/g
+  let lastIndex = 0
+  let match: RegExpExecArray | null
+
+  while ((match = regex.exec(cleanedLine)) !== null) {
+    // Add text before this escape sequence
+    if (match.index > lastIndex) {
+      const text = cleanedLine.slice(lastIndex, match.index)
+      if (text) {
+        segments.push({
+          text,
+          fg: state.fg,
+          bg: state.bg,
+          bold: state.bold || undefined,
+        })
+      }
+    }
+
+    // Parse SGR parameters
+    const paramStr = match[1] ?? ""
+    const params = paramStr === "" ? [0] : paramStr.split(";").map((s) => parseInt(s, 10) || 0)
+    parseSGR(params, state)
+
+    lastIndex = regex.lastIndex
+  }
+
+  // Add remaining text after last escape sequence
+  if (lastIndex < cleanedLine.length) {
+    const text = cleanedLine.slice(lastIndex)
+    if (text) {
+      segments.push({
+        text,
+        fg: state.fg,
+        bg: state.bg,
+        bold: state.bold || undefined,
+      })
+    }
+  }
+
+  // If no segments, return single segment with cleaned text
+  if (segments.length === 0) {
+    const stripped = cleanedLine.replace(/\x1B\[[0-9;]*m/g, "")
+    return [{ text: stripped || " " }]
+  }
+
+  return segments
+}