nastechai-desktop 18.1.0

package/src/lib/keybinds/combo.ts

@@ -0,0 +1,169 @@
+// Keybind combo normalization + display.
+//
+// A combo is a canonical lowercase string like "mod+k", "mod+shift+]", "shift+x",
+// or "r". `mod` is Cmd on macOS / Ctrl elsewhere, so a single binding works on
+// both. We derive the base key from `event.code` (not `event.key`) so Shift never
+// mutates it ("shift+/" stays "shift+/" instead of becoming "shift+?").
+
+export const IS_MAC =
+  typeof navigator !== 'undefined' && /mac/i.test(navigator.platform || navigator.userAgent || '')
+
+// event.code → canonical base token. Letters/digits map to their lowercase
+// character; everything else uses an explicit name so combos read cleanly.
+const CODE_TO_KEY: Record<string, string> = {
+  Backquote: '`',
+  Backslash: '\\',
+  BracketLeft: '[',
+  BracketRight: ']',
+  Comma: ',',
+  Equal: '=',
+  Minus: '-',
+  Period: '.',
+  Quote: "'",
+  Semicolon: ';',
+  Slash: '/',
+  Space: 'space',
+  Enter: 'enter',
+  Escape: 'escape',
+  Backspace: 'backspace',
+  Tab: 'tab',
+  ArrowUp: 'up',
+  ArrowDown: 'down',
+  ArrowLeft: 'left',
+  ArrowRight: 'right'
+}
+
+const MODIFIER_CODES = new Set([
+  'AltLeft',
+  'AltRight',
+  'ControlLeft',
+  'ControlRight',
+  'MetaLeft',
+  'MetaRight',
+  'ShiftLeft',
+  'ShiftRight'
+])
+
+function baseKeyFromCode(code: string): string | null {
+  if (code.startsWith('Key')) {
+    return code.slice(3).toLowerCase()
+  }
+
+  if (code.startsWith('Digit')) {
+    return code.slice(5)
+  }
+
+  if (code.startsWith('Numpad')) {
+    const rest = code.slice(6)
+
+    return /^[0-9]$/.test(rest) ? rest : null
+  }
+
+  if (code.startsWith('F') && /^F\d{1,2}$/.test(code)) {
+    return code.toLowerCase()
+  }
+
+  return CODE_TO_KEY[code] ?? null
+}
+
+// Returns the canonical combo for a keydown, or null while only modifiers are
+// held (so capture mode keeps waiting for a real key).
+export function comboFromEvent(event: KeyboardEvent): string | null {
+  if (MODIFIER_CODES.has(event.code)) {
+    return null
+  }
+
+  const base = baseKeyFromCode(event.code)
+
+  if (!base) {
+    return null
+  }
+
+  const parts: string[] = []
+
+  if (event.metaKey || event.ctrlKey) {
+    parts.push('mod')
+  }
+
+  if (event.altKey) {
+    parts.push('alt')
+  }
+
+  if (event.shiftKey) {
+    parts.push('shift')
+  }
+
+  parts.push(base)
+
+  return parts.join('+')
+}
+
+const TOKEN_LABELS: Record<string, string> = {
+  enter: '↵',
+  escape: 'Esc',
+  backspace: '⌫',
+  tab: '⇥',
+  space: 'Space',
+  up: '↑',
+  down: '↓',
+  left: '←',
+  right: '→'
+}
+
+function labelForBase(base: string): string {
+  if (TOKEN_LABELS[base]) {
+    return TOKEN_LABELS[base]
+  }
+
+  if (/^f\d{1,2}$/.test(base)) {
+    return base.toUpperCase()
+  }
+
+  return base.length === 1 ? base.toUpperCase() : base
+}
+
+// Human-readable label, e.g. "⌘⇧K" on macOS, "Ctrl+Shift+K" elsewhere.
+export function formatCombo(combo: string): string {
+  const parts = combo.split('+')
+  const base = parts.pop() ?? ''
+  const mods = parts
+
+  const modLabels = mods.map(mod => {
+    if (mod === 'mod') {
+      return IS_MAC ? '⌘' : 'Ctrl'
+    }
+
+    if (mod === 'alt') {
+      return IS_MAC ? '⌥' : 'Alt'
+    }
+
+    if (mod === 'shift') {
+      return IS_MAC ? '⇧' : 'Shift'
+    }
+
+    return mod
+  })
+
+  const tokens = [...modLabels, labelForBase(base)]
+
+  return IS_MAC ? tokens.join('') : tokens.join('+')
+}
+
+// True when focus is in a text-entry surface, so bare-key shortcuts don't fire
+// while the user is typing.
+export function isEditableTarget(target: EventTarget | null): boolean {
+  const el = target as HTMLElement | null
+
+  return Boolean(
+    el?.isContentEditable ||
+      el instanceof HTMLInputElement ||
+      el instanceof HTMLTextAreaElement ||
+      el instanceof HTMLSelectElement
+  )
+}
+
+// Combos with a primary modifier (Cmd/Ctrl) are safe to fire even while typing
+// (e.g. ⌘K from the composer); bare/Shift-only combos are suppressed in inputs.
+export function comboAllowedInInput(combo: string): boolean {
+  return combo.startsWith('mod+') || combo === 'mod'
+}

package/src/lib/local-preview.ts

@@ -0,0 +1,126 @@
+import type { PreviewTarget } from '@/store/preview'
+
+const HTML_EXTENSIONS = new Set(['.htm', '.html'])
+const IMAGE_EXTENSIONS = new Set(['.bmp', '.gif', '.jpeg', '.jpg', '.png', '.svg', '.webp'])
+
+const LANGUAGE_BY_EXT: Record<string, string> = {
+  '.c': 'c',
+  '.conf': 'ini',
+  '.cpp': 'cpp',
+  '.css': 'css',
+  '.csv': 'csv',
+  '.go': 'go',
+  '.graphql': 'graphql',
+  '.h': 'c',
+  '.hpp': 'cpp',
+  '.html': 'html',
+  '.java': 'java',
+  '.js': 'javascript',
+  '.json': 'json',
+  '.jsx': 'jsx',
+  '.log': 'text',
+  '.lua': 'lua',
+  '.md': 'markdown',
+  '.mjs': 'javascript',
+  '.py': 'python',
+  '.rb': 'ruby',
+  '.rs': 'rust',
+  '.sh': 'shell',
+  '.sql': 'sql',
+  '.svg': 'xml',
+  '.toml': 'toml',
+  '.ts': 'typescript',
+  '.tsx': 'tsx',
+  '.txt': 'text',
+  '.xml': 'xml',
+  '.yaml': 'yaml',
+  '.yml': 'yaml',
+  '.zsh': 'shell'
+}
+
+function basename(value: string) {
+  return value.split(/[\\/]/).filter(Boolean).pop() || value
+}
+
+function extension(value: string) {
+  const clean = value.split(/[?#]/, 1)[0] || value
+  const idx = clean.lastIndexOf('.')
+
+  return idx >= 0 ? clean.slice(idx).toLowerCase() : ''
+}
+
+function joinPath(base: string, rel: string) {
+  if (!base) {
+    return rel
+  }
+
+  return `${base.replace(/\/+$/, '')}/${rel.replace(/^\.?\//, '')}`
+}
+
+function pathToFileUrl(path: string) {
+  const encoded = path
+    .split('/')
+    .map(part => encodeURIComponent(part))
+    .join('/')
+
+  return `file://${encoded.startsWith('/') ? encoded : `/${encoded}`}`
+}
+
+export function localPreviewTarget(rawTarget: string, cwd?: string | null): PreviewTarget | null {
+  const raw = rawTarget.trim().replace(/^`|`$/g, '')
+
+  if (!raw) {
+    return null
+  }
+
+  if (/^https?:\/\//i.test(raw)) {
+    return { kind: 'url', label: basename(raw), source: raw, url: raw }
+  }
+
+  let path = raw
+
+  if (/^file:\/\//i.test(raw)) {
+    try {
+      path = decodeURIComponent(new URL(raw).pathname)
+    } catch {
+      path = raw.replace(/^file:\/\//i, '')
+    }
+  } else if (!raw.startsWith('/') && cwd) {
+    path = joinPath(cwd, raw)
+  }
+
+  const ext = extension(path)
+  const isHtml = HTML_EXTENSIONS.has(ext)
+  const isImage = IMAGE_EXTENSIONS.has(ext)
+
+  return {
+    kind: 'file',
+    label: basename(path),
+    language: LANGUAGE_BY_EXT[ext] || 'text',
+    path,
+    // Renderer fallback can't stat/sniff without reading; assume text unless
+    // image/html extension says otherwise. LocalFilePreview still guards
+    // binary/large files when readFileText/readFileDataUrl returns metadata.
+    previewKind: isHtml ? 'html' : isImage ? 'image' : 'text',
+    source: raw,
+    url: pathToFileUrl(path)
+  }
+}
+
+export async function normalizeOrLocalPreviewTarget(
+  rawTarget: string,
+  cwd?: string | null
+): Promise<PreviewTarget | null> {
+  try {
+    const normalized = await window.NASTECHDesktop?.normalizePreviewTarget?.(rawTarget, cwd || undefined)
+
+    if (normalized) {
+      return normalized
+    }
+  } catch {
+    // Running Electron may still have the old HTML-only preview IPC. Fall
+    // through to renderer-side local classification so text/images still open.
+  }
+
+  return localPreviewTarget(rawTarget, cwd)
+}

package/src/lib/markdown-code.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest'
+
+import { isLikelyProseCodeBlock } from './markdown-code'
+
+describe('isLikelyProseCodeBlock', () => {
+  it('detects prose that Streamdown mislabels as an unknown language', () => {
+    expect(
+      isLikelyProseCodeBlock(
+        'heads',
+        [
+          '- Pure white (`#ffffff`), roughness 0.55, no emissive',
+          '- Black wireframe edges at 35% opacity',
+          '',
+          'Want the bunny gone, or want me to keep riffing on it?'
+        ].join('\n')
+      )
+    ).toBe(true)
+  })
+
+  it('keeps real code blocks', () => {
+    expect(isLikelyProseCodeBlock('ts', 'const value = { bunny: true };\nreturn value')).toBe(false)
+  })
+})

package/src/lib/markdown-code.ts

@@ -0,0 +1,195 @@
+const VALID_LANGUAGE_RE = /^[a-z0-9][a-z0-9+#-]*$/i
+const NON_CODE_FENCE_LANGUAGES = new Set(['', 'text', 'plain', 'plaintext', 'md', 'markdown'])
+
+const COMMON_CODE_LANGUAGES = new Set([
+  'bash',
+  'c',
+  'cpp',
+  'css',
+  'diff',
+  'go',
+  'html',
+  'java',
+  'javascript',
+  'js',
+  'json',
+  'jsx',
+  'markdown',
+  'md',
+  'php',
+  'python',
+  'py',
+  'ruby',
+  'rust',
+  'rs',
+  'sh',
+  'sql',
+  'swift',
+  'tsx',
+  'ts',
+  'typescript',
+  'xml',
+  'yaml',
+  'yml'
+])
+
+interface CodeSignals {
+  bulletLines: number
+  codeSignals: number
+  hasMarkdown: boolean
+  proseLines: number
+  trimmed: string
+  urlLines: number
+}
+
+export function sanitizeLanguageTag(tag: string): string {
+  const trimmed = tag.trim()
+  const first = trimmed.split(/\s/, 1)[0] || ''
+
+  return VALID_LANGUAGE_RE.test(first) && first.length <= 16 ? first.toLowerCase() : ''
+}
+
+// Sanitized language tag → codicon glyph. Anything not listed falls back to
+// the generic `code` glyph, which matches what the tool-row icons use.
+const CODICON_BY_LANGUAGE: Record<string, string> = {
+  bash: 'terminal',
+  cmd: 'terminal',
+  console: 'terminal',
+  fish: 'terminal',
+  powershell: 'terminal',
+  ps1: 'terminal',
+  sh: 'terminal',
+  shell: 'terminal',
+  zsh: 'terminal',
+
+  md: 'markdown',
+  markdown: 'markdown',
+
+  json: 'json',
+  json5: 'json',
+
+  ini: 'settings-gear',
+  toml: 'settings-gear',
+  yaml: 'settings-gear',
+  yml: 'settings-gear',
+  dotenv: 'settings-gear',
+  env: 'settings-gear',
+
+  graphql: 'database',
+  gql: 'database',
+  mysql: 'database',
+  postgres: 'database',
+  postgresql: 'database',
+  sql: 'database',
+  sqlite: 'database',
+
+  diff: 'diff',
+  patch: 'diff',
+
+  css: 'symbol-color',
+  less: 'symbol-color',
+  sass: 'symbol-color',
+  scss: 'symbol-color',
+  svg: 'symbol-color',
+
+  regex: 'regex',
+  regexp: 'regex',
+
+  curl: 'globe',
+  http: 'globe',
+
+  docker: 'package',
+  dockerfile: 'package',
+
+  mermaid: 'graph'
+}
+
+export function codiconForLanguage(language: string | undefined): string {
+  return CODICON_BY_LANGUAGE[sanitizeLanguageTag(language || '')] || 'code'
+}
+
+function proseLineCount(body: string): number {
+  return body.split('\n').filter(line => {
+    const trimmed = line.trim()
+
+    return Boolean(trimmed) && /^[A-Za-z0-9"'`*-]/.test(trimmed)
+  }).length
+}
+
+const CODE_SIGNAL_RE = [
+  /(^|\s)(const|let|var|function|class|import|export|return|if|for|while|switch)\b/gim,
+  /=>|==|===|!=|!==|\{|\}|;|<\/?[a-z][^>]*>/gi,
+  /^\s*(#include|SELECT|INSERT|UPDATE|DELETE|CREATE|DROP)\b/gim
+]
+
+function codeSignalCount(body: string): number {
+  return CODE_SIGNAL_RE.reduce((total, pattern) => total + (body.match(pattern)?.length ?? 0), 0)
+}
+
+function codeSignals(body: string): CodeSignals {
+  const trimmed = body.trim()
+  const markdownSignals = (trimmed.match(/\*\*[^*]+\*\*/g) || []).length + (trimmed.match(/`[^`\n]+`/g) || []).length
+
+  return {
+    bulletLines: (trimmed.match(/^\s*[-*]\s+\S+/gm) || []).length,
+    codeSignals: codeSignalCount(trimmed),
+    hasMarkdown: markdownSignals > 0,
+    proseLines: proseLineCount(trimmed),
+    trimmed,
+    urlLines: (trimmed.match(/^\s*https?:\/\/\S+\s*$/gim) || []).length
+  }
+}
+
+export function isLikelyProseFence(info: string, body: string): boolean {
+  const trimmedInfo = info.trim()
+  const rawInfo = trimmedInfo.toLowerCase()
+  const language = sanitizeLanguageTag(info)
+  const infoToken = trimmedInfo.split(/\s+/, 1)[0] || ''
+  const hasInfoTail = Boolean(trimmedInfo) && trimmedInfo !== infoToken
+
+  if (/^[-*+]\s/.test(rawInfo) || /^https?:\/\//.test(rawInfo)) {
+    return true
+  }
+
+  const signals = codeSignals(body)
+
+  if (!signals.trimmed) {
+    return false
+  }
+
+  if (
+    hasInfoTail &&
+    signals.codeSignals <= 2 &&
+    (signals.proseLines >= 2 || signals.bulletLines >= 1 || signals.urlLines >= 1)
+  ) {
+    return true
+  }
+
+  if (!NON_CODE_FENCE_LANGUAGES.has(language)) {
+    return false
+  }
+
+  return (
+    (signals.bulletLines >= 2 && signals.hasMarkdown && signals.codeSignals <= 2) ||
+    (signals.proseLines >= 3 && signals.codeSignals === 0)
+  )
+}
+
+export function isLikelyProseCodeBlock(language: string | undefined, code: string | undefined): boolean {
+  const cleanLanguage = sanitizeLanguageTag(language || '')
+  const signals = codeSignals(code || '')
+
+  if (!signals.trimmed || signals.codeSignals >= 3) {
+    return false
+  }
+
+  if (signals.bulletLines >= 1 && (signals.hasMarkdown || signals.proseLines >= 2)) {
+    return true
+  }
+
+  if (NON_CODE_FENCE_LANGUAGES.has(cleanLanguage)) {
+    return signals.proseLines >= 3 && signals.codeSignals === 0
+  }
+
+  return !COMMON_CODE_LANGUAGES.has(cleanLanguage) && signals.proseLines >= 2 && signals.codeSignals <= 1
+}