dsh-code 1.2.0 → 1.4.0

package/src/attachments.ts

@@ -52,17 +52,41 @@ export function looksLikeImagePath(path: string): boolean {
   return IMAGE_EXTENSIONS.has(extname(path).toLowerCase())
 }
 
+/** Strip one layer of ASCII or Unicode quotes and shell-escaped spaces. */
+export function unwrapDroppedPath(token: string): string {
+  const trimmed = token.trim()
+  const wrapped = /^[\u2018\u201C"'](.+)[\u2019\u201D"']$/u.exec(trimmed)
+  return (wrapped?.[1] ?? trimmed).replace(/\\ /gu, ' ')
+}
+
+/** Absolute/relative drop with a dotted leaf — including unquoted spaces. */
+export function looksLikeFilesystemDrop(path: string): boolean {
+  if (path.startsWith('file://')) return true
+  if (!/^(?:\/|[A-Za-z]:[\\/]|\\\\|\.\.?\/)/u.test(path)) return false
+  return looksLikeImagePath(path) || /\.[A-Za-z0-9]{1,16}$/u.test(path)
+}
+
 /**
- * Parse a paste/drop into its image and file paths: image-suffixed tokens
- * stay images, other path-shaped tokens ride as file attachments (0.1.5
- * file blocks), and anything that is neither leaves both empty — the caller
- * then treats the paste as plain text.
+ * A composer draft that is a filesystem path, not a slash command.
+ * `/usage` stays a command; `/Users/foo.png` and `C:\temp\a.png` are drops.
+ */
+export function looksLikePathDraft(value: string): boolean {
+  const path = unwrapDroppedPath(value)
+  if (looksLikeFilesystemDrop(path)) return true
+  return /^\/(?:Users|home|tmp|var|etc|opt|mnt|Volumes)\//u.test(path)
+}
+
+/**
+ * Parse a paste or file-drop into image and file paths: image-suffixed
+ * tokens stay images, other path-shaped tokens ride as file attachments
+ * (0.1.5 file blocks), and anything that is neither leaves both empty —
+ * the caller then treats the paste as plain text.
  *
  * File tokens are held to an absolute-path-with-shape bar (drive/backslash
- * or a dot-suffixed leaf after a separator): a dropped terminal path always
+ * or a dotted leaf after a separator): a dropped terminal path always
  * carries one of those, while prose, slash commands, and option flags never
- * do. A POSIX absolute path without any dot-suffixed leaf falls through as
- * text — the @ mention route still attaches such files deliberately.
+ * do. A POSIX absolute path without a dotted leaf falls through as text —
+ * the @ mention route still attaches such files deliberately.
  */
 export function parsePastedAttachmentPaths(input: string): { readonly images: readonly string[]; readonly files: readonly string[] } {
   const text = input.trim()
@@ -73,27 +97,49 @@ export function parsePastedAttachmentPaths(input: string): { readonly images: re
     /^[A-Za-z]:[\\/]/u.test(path)
     || /^\\\\/u.test(path)
     || (/^\/|^\.\.?\//u.test(path) && /\.[A-Za-z0-9]{1,16}$/u.test(path))
-  const matcher = /"([^"]+)"|'([^']+)'|(\S+)/gu
-  for (const match of text.matchAll(matcher)) {
-    const token = match[1] ?? match[2] ?? match[3]
-    if (token === undefined) continue
-    let path = token
+  const classify = (raw: string): 'image' | 'file' | 'reject' => {
+    let path = unwrapDroppedPath(raw)
     if (path.startsWith('file://')) {
       try {
         path = fileURLToPath(path)
       } catch {
-        return { images: [], files: [] }
+        return 'reject'
+      }
+    } else if (/%[0-9A-Fa-f]{2}/u.test(path)) {
+      try {
+        path = decodeURIComponent(path)
+      } catch {
+        // Keep the raw token when it is not a valid percent-encoding.
       }
-      if (looksLikeImagePath(path)) images.push(path)
-      else files.push(path)
-      continue
     }
     if (looksLikeImagePath(path)) {
       images.push(path)
-      continue
+      return 'image'
+    }
+    if (looksLikeDroppedFile(path) || looksLikeFilesystemDrop(path)) {
+      files.push(path)
+      return 'file'
     }
-    if (!looksLikeDroppedFile(path)) return { images: [], files: [] }
-    files.push(path)
+    return 'reject'
+  }
+  // A single dropped path with spaces often arrives unquoted (macOS, Windows
+  // Explorer, VS Code sendText). Use the whole paste only when there is one
+  // path start and the text actually contains spaces (or wrapping quotes) —
+  // two unquoted `C:\a.png D:\b.txt` tokens must still split.
+  const whole = unwrapDroppedPath(text)
+  const pathStarts = text.match(/(?:^|[\s"'])(?:\/|[A-Za-z]:[\\/]|\\\\|\.\.?\/|file:\/\/)/gu) ?? []
+  const spacedSingleton = pathStarts.length <= 1
+    && looksLikeFilesystemDrop(whole)
+    && (/\s/u.test(whole) || /^[\u2018\u201C"']/u.test(text))
+  if (spacedSingleton) {
+    classify(whole)
+    return { images, files }
+  }
+  const matcher = /"([^"]+)"|'([^']+)'|(\S+)/gu
+  for (const match of text.matchAll(matcher)) {
+    const token = match[1] ?? match[2] ?? match[3]
+    if (token === undefined) continue
+    if (classify(token) === 'reject') return { images: [], files: [] }
   }
   return { images, files }
 }

package/src/completion.ts

@@ -0,0 +1,117 @@
+/** Slash-command parsing and completion candidates shared by the composer and help panel. */
+
+import type { CommandDescriptor } from '@deepseek-ai/dsh-commands'
+import { t, type MessageKey } from './i18n.ts'
+import { rankByName } from './render/fuzzy.ts'
+import type { SkillRow } from './skills.ts'
+
+/** One TUI-owned slash command: label plus its i18n description key. */
+export interface LocalCommand {
+  readonly label: string
+  readonly descriptionKey: MessageKey
+}
+
+/** One source of truth for TUI-owned slash commands in completion and `/help`. */
+export const LOCAL_COMMANDS: readonly LocalCommand[] = [
+  { label: '/help', descriptionKey: 'cmd.help' },
+  { label: '/model', descriptionKey: 'cmd.model' },
+  { label: '/effort', descriptionKey: 'cmd.effort' },
+  { label: '/mode', descriptionKey: 'cmd.mode' },
+  { label: '/permission', descriptionKey: 'cmd.permission' },
+  { label: '/new', descriptionKey: 'cmd.new' },
+  { label: '/fork', descriptionKey: 'cmd.fork' },
+  { label: '/resume', descriptionKey: 'cmd.resume' },
+  { label: '/search', descriptionKey: 'cmd.search' },
+  { label: '/plugin', descriptionKey: 'cmd.plugin' },
+  { label: '/update', descriptionKey: 'cmd.update' },
+  { label: '/jobs', descriptionKey: 'cmd.jobs' },
+  { label: '/schedule', descriptionKey: 'cmd.schedule' },
+  { label: '/statusline', descriptionKey: 'cmd.statusline' },
+  { label: '/theme', descriptionKey: 'cmd.theme' },
+  { label: '/language', descriptionKey: 'cmd.language' },
+  { label: '/rainbow', descriptionKey: 'cmd.rainbow' },
+  { label: '/animation', descriptionKey: 'cmd.animation' },
+  { label: '/history', descriptionKey: 'cmd.history' },
+  { label: '/queue', descriptionKey: 'cmd.queue' },
+  { label: '/usage', descriptionKey: 'cmd.usage' },
+  { label: '/agents', descriptionKey: 'cmd.agents' },
+  { label: '/todos', descriptionKey: 'cmd.todos' },
+  { label: '/subagent', descriptionKey: 'cmd.subagent' },
+  { label: '/vscode-keys', descriptionKey: 'cmd.vscode-keys' },
+  { label: '/delete', descriptionKey: 'cmd.delete' },
+  { label: '/clear', descriptionKey: 'cmd.clear' },
+  { label: '/export', descriptionKey: 'cmd.export' },
+  { label: '/title', descriptionKey: 'cmd.title' },
+  { label: '/copy', descriptionKey: 'cmd.copy' },
+  { label: '/diff', descriptionKey: 'cmd.diff' },
+  { label: '/review', descriptionKey: 'cmd.review' },
+  { label: '/quit', descriptionKey: 'cmd.quit' },
+] as const
+
+export const LOCAL_COMMAND_NAMES: ReadonlySet<string> = new Set(LOCAL_COMMANDS.map(command => command.label.slice(1)))
+
+/** TUI-local commands that reject trailing input instead of forwarding it as a prompt. */
+export const BARE_LOCAL_COMMANDS: ReadonlySet<string> = new Set([
+  'quit', 'help', 'clear', 'copy', 'update', 'schedule', 'statusline', 'theme',
+  'history', 'queue', 'usage', 'agents', 'todos', 'subagent',
+])
+
+/** Split a slash line into the command name and any trailing input. */
+export function slashNameAndArgs(text: string): { readonly name: string; readonly args: string } | undefined {
+  const match = /^\/([a-z][a-z0-9_-]*)(?:$|[\t ](.*))$/u.exec(text)
+  if (match === null || match[1] === undefined) return undefined
+  return { name: match[1], args: (match[2] ?? '').trim() }
+}
+
+/** One completion candidate row. */
+export interface CompletionCandidate {
+  readonly label: string
+  readonly description: string
+  readonly origin: 'command' | 'skill' | 'mention'
+}
+
+/** Wrap one completion-menu cursor step; an empty menu keeps the index at zero. */
+export function stepCompletionIndex(index: number, delta: number, count: number): number {
+  if (count <= 0) return 0
+  return ((index + delta) % count + count) % count
+}
+
+/** Merge local commands, registry descriptors, and skills using dispatch shadowing order. */
+export function completionCandidates(
+  value: string,
+  descriptors: readonly CommandDescriptor[],
+  skills: readonly SkillRow[],
+): readonly CompletionCandidate[] {
+  if (!value.startsWith('/')) return []
+  const prefix = value.slice(1).split(' ')[0] ?? ''
+  const local: CompletionCandidate[] = LOCAL_COMMANDS.map(command => ({
+    label: command.label,
+    description: t(command.descriptionKey),
+    origin: 'command',
+  }))
+  const registry = descriptors
+    .filter(descriptor => !LOCAL_COMMAND_NAMES.has(descriptor.name))
+    .map((descriptor): CompletionCandidate => ({
+      label: `/${descriptor.name}`,
+      description: descriptor.description,
+      origin: 'command',
+    }))
+  const taken = new Set([...local, ...registry].map(candidate => candidate.label.slice(1)))
+  const skillRows = skills
+    .filter(skill => !taken.has(skill.name))
+    .map((skill): CompletionCandidate => ({
+      label: `/${skill.name}`,
+      description: skill.modelInvocable ? `skill · ${skill.description}` : `skill (user only) · ${skill.description}`,
+      origin: 'skill',
+    }))
+  const seen = new Set<string>()
+  const all: CompletionCandidate[] = []
+  for (const candidate of [...local, ...registry, ...skillRows]) {
+    const name = candidate.label.slice(1)
+    if (seen.has(name)) continue
+    seen.add(name)
+    all.push(candidate)
+  }
+  return rankByName(all.map(candidate => ({ name: candidate.label.slice(1), candidate })), prefix)
+    .map(entry => entry.candidate)
+}