feat(desktop): add batch file selection from clipboard in file tree

Author: kccarlos

apps/desktop/src-tauri/tauri.conf.json

@@ -49,6 +49,7 @@
             "dialog:allow-open",
             "fs:allow-read-dir",
             "fs:allow-read-file",
+            "clipboard-manager:allow-read-text",
             "clipboard-manager:allow-write-text"
           ]
         }

apps/desktop/src/App.tsx

@@ -3,7 +3,7 @@ import './App.css'
 import { ChevronsDown, ChevronsUp, CheckSquare, Square, Sun, Moon, Folder, FolderGit2, ListChecks, Copy, ArrowLeftRight } from 'lucide-react'
 import { FileTreeView, PreviewModal, GitHubStarIconButton, BugIconButton } from '@gitcontext/ui'
 import { type FileDiffStatus, isBinaryPath, MAX_CONCURRENT_READS } from '@gitcontext/core'
-import { writeText } from '@tauri-apps/plugin-clipboard-manager'
+import { readText, writeText } from '@tauri-apps/plugin-clipboard-manager'
 import { useGitRepository } from './hooks/useGitRepository'
 import { useFileTree } from './hooks/useFileTree'
 import { SelectedFilesPanel } from './components/SelectedFilesPanel'
@@ -21,6 +21,12 @@ import { TokenCountsProvider } from './context/TokenCountsContext'
 import { mapWithConcurrency } from './utils/concurrency'
 import { logError } from './utils/logger'
 import { debounce } from './utils/debounce'
+import {
+  INVALID_CLIPBOARD_FORMAT_MESSAGE,
+  NO_MATCHING_FILES_MESSAGE,
+  parseClipboardPathLines,
+  resolveSelectablePaths,
+} from './utils/clipboardBatchSelect'
 
 function AppContent() {
   const [, setAppStatus] = useState<AppStatus>({ state: 'IDLE' })
@@ -152,6 +158,7 @@ function AppContent() {
     collapseAll,
     selectAll,
     deselectAll,
+    addSelectedPaths,
     revealPath,
   } = useFileTree(setAppStatus)
 
@@ -356,6 +363,37 @@ function AppContent() {
     }
   }, [gitClient, baseBranch, compareBranch, selectedPaths, diffContextLines, statusByPath, userInstructions, fileTree, includeFileTree, showChangedOnly, currentDir])
 
+  const handleBatchSelectFromClipboard = useCallback(async () => {
+    if (!currentDir || !fileTree) return
+
+    try {
+      const clipboardText = await readText()
+      const lines = parseClipboardPathLines(clipboardText)
+      if (lines.length === 0) {
+        setErrorMessage(INVALID_CLIPBOARD_FORMAT_MESSAGE)
+        return
+      }
+
+      const selectableSet = new Set(statusByPath.keys())
+      const { matched, invalidCount, outsideRepoCount } = resolveSelectablePaths(lines, currentDir, selectableSet)
+
+      if (matched.length === 0) {
+        if (invalidCount === lines.length && outsideRepoCount === 0) {
+          setErrorMessage(INVALID_CLIPBOARD_FORMAT_MESSAGE)
+        } else {
+          setErrorMessage(NO_MATCHING_FILES_MESSAGE)
+        }
+        return
+      }
+
+      addSelectedPaths(matched)
+      setErrorMessage(null)
+    } catch (err) {
+      logError('batchSelectFromClipboard', err)
+      setErrorMessage('Failed to read clipboard content.')
+    }
+  }, [currentDir, fileTree, statusByPath, addSelectedPaths])
+
   // Calculate file tree tokens
   useEffect(() => {
     if (!includeFileTree || !fileTree || selectedPaths.size === 0) {
@@ -539,6 +577,7 @@ function AppContent() {
                     <button onClick={collapseAll} className="btn btn-ghost btn-icon" title="Collapse All" disabled={!fileTree}><ChevronsUp size={14} /></button>
                     <button onClick={() => selectAll(treeFilter)} className="btn btn-ghost btn-icon" title="Select All" disabled={!fileTree}><CheckSquare size={14} /></button>
                     <button onClick={() => deselectAll(treeFilter)} className="btn btn-ghost btn-icon" title="Deselect All" disabled={!fileTree}><Square size={14} /></button>
+                    <button onClick={() => void handleBatchSelectFromClipboard()} className="btn btn-ghost btn-icon" title="Batch Select from Clipboard" disabled={!fileTree || !currentDir}><ListChecks size={14} /></button>
                   </div>
                   <label className="tree-filter-checkbox">
                     <input type="checkbox" checked={showChangedOnly} onChange={(e) => setShowChangedOnly(e.target.checked)} />

apps/desktop/src/hooks/useFileTree.ts

@@ -281,6 +281,15 @@ export function useFileTree(setAppStatus?: (s: AppStatus) => void) {
     })
   }, [fileTree, showChangedOnly])
 
+  const addSelectedPaths = useCallback((paths: string[]) => {
+    if (!paths.length) return
+    setSelectedPaths((prev) => {
+      const next = new Set(prev)
+      for (const path of paths) next.add(path)
+      return next
+    })
+  }, [])
+
   const revealPath = useCallback((path: string) => {
     if (!fileTree) return
 
@@ -339,6 +348,7 @@ export function useFileTree(setAppStatus?: (s: AppStatus) => void) {
     collapseAll,
     selectAll,
     deselectAll,
+    addSelectedPaths,
     revealPath,
   }
 }

apps/desktop/src/utils/clipboardBatchSelect.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest'
+import {
+  normalizeClipboardPath,
+  parseClipboardPathLines,
+  resolveSelectablePaths,
+} from './clipboardBatchSelect'
+
+describe('clipboardBatchSelect', () => {
+  it('parses newline-delimited paths and ignores blank lines', () => {
+    const parsed = parseClipboardPathLines('\n src/App.tsx \n\nREADME.md\r\n')
+    expect(parsed).toEqual(['src/App.tsx', 'README.md'])
+  })
+
+  it('normalizes absolute path inside repo to relative', () => {
+    const result = normalizeClipboardPath('/Users/me/repo/src/App.tsx', '/Users/me/repo')
+    expect(result).toBe('src/App.tsx')
+  })
+
+  it('normalizes windows separators for relative paths', () => {
+    const result = normalizeClipboardPath('src\\components\\Tree.tsx', '/Users/me/repo')
+    expect(result).toBe('src/components/Tree.tsx')
+  })
+
+  it('returns null for absolute path outside repo', () => {
+    const result = normalizeClipboardPath('/Users/me/other-repo/src/App.tsx', '/Users/me/repo')
+    expect(result).toBeNull()
+  })
+
+  it('resolves mixed input with inside and outside repo paths', () => {
+    const selectableSet = new Set(['src/App.tsx', 'README.md'])
+    const result = resolveSelectablePaths(
+      ['src/App.tsx', '/Users/me/repo/README.md', '/Users/me/other/repo.ts'],
+      '/Users/me/repo',
+      selectableSet
+    )
+
+    expect(result.matched.sort()).toEqual(['README.md', 'src/App.tsx'])
+    expect(result.invalidCount).toBe(0)
+    expect(result.outsideRepoCount).toBe(1)
+  })
+})

apps/desktop/src/utils/clipboardBatchSelect.ts

@@ -0,0 +1,98 @@
+export const INVALID_CLIPBOARD_FORMAT_MESSAGE =
+  'Invalid clipboard format. Paste one file path per line (relative or absolute path inside this repo). Example:\nsrc/App.tsx\napps/desktop/src/App.tsx'
+
+export const NO_MATCHING_FILES_MESSAGE =
+  'No matching files were found in this repository. Paste one file path per line (relative or absolute inside the opened repo).'
+
+const DRIVE_LETTER_ABS = /^[a-zA-Z]:\//
+const WINDOWS_UNC_ABS = /^\/\//
+
+function normalizeSlashes(value: string): string {
+  return value.replace(/\\/g, '/')
+}
+
+function stripTrailingSlashes(value: string): string {
+  return value.replace(/\/+$/, '')
+}
+
+function stripLeadingSlashes(value: string): string {
+  return value.replace(/^\/+/, '')
+}
+
+function stripLeadingDotSlash(value: string): string {
+  return value.replace(/^\.\/+/, '')
+}
+
+function isAbsolutePath(value: string): boolean {
+  return value.startsWith('/') || DRIVE_LETTER_ABS.test(value) || WINDOWS_UNC_ABS.test(value)
+}
+
+function equalForFs(a: string, b: string): boolean {
+  const driveA = DRIVE_LETTER_ABS.test(a)
+  const driveB = DRIVE_LETTER_ABS.test(b)
+  if (driveA || driveB) return a.toLowerCase() === b.toLowerCase()
+  return a === b
+}
+
+function startsWithForFs(path: string, prefix: string): boolean {
+  const drivePath = DRIVE_LETTER_ABS.test(path)
+  const drivePrefix = DRIVE_LETTER_ABS.test(prefix)
+  if (drivePath || drivePrefix) return path.toLowerCase().startsWith(prefix.toLowerCase())
+  return path.startsWith(prefix)
+}
+
+export function parseClipboardPathLines(text: string): string[] {
+  return text
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+}
+
+export function normalizeClipboardPath(line: string, repoRoot: string): string | null {
+  const normalizedRepoRoot = stripTrailingSlashes(normalizeSlashes(repoRoot.trim()))
+  if (!normalizedRepoRoot) return null
+
+  const normalizedLine = normalizeSlashes(line.trim())
+  if (!normalizedLine) return null
+
+  if (isAbsolutePath(normalizedLine)) {
+    const repoPrefix = `${normalizedRepoRoot}/`
+    if (equalForFs(normalizedLine, normalizedRepoRoot)) return null
+    if (!startsWithForFs(normalizedLine, repoPrefix)) return null
+    return stripLeadingSlashes(normalizedLine.slice(repoPrefix.length))
+  }
+
+  const relative = stripLeadingDotSlash(stripLeadingSlashes(normalizedLine))
+  return relative || null
+}
+
+export function resolveSelectablePaths(
+  lines: string[],
+  repoRoot: string,
+  selectableSet: Set<string>
+): { matched: string[]; invalidCount: number; outsideRepoCount: number } {
+  const matched = new Set<string>()
+  let invalidCount = 0
+  let outsideRepoCount = 0
+
+  for (const line of lines) {
+    const normalized = normalizeClipboardPath(line, repoRoot)
+    if (!normalized) {
+      if (isAbsolutePath(normalizeSlashes(line.trim()))) outsideRepoCount++
+      else invalidCount++
+      continue
+    }
+    const repoRelativePath = normalizeSlashes(normalized)
+    if (selectableSet.has(repoRelativePath)) {
+      matched.add(repoRelativePath)
+    } else {
+      outsideRepoCount++
+    }
+  }
+
+  return {
+    matched: Array.from(matched),
+    invalidCount,
+    outsideRepoCount,
+  }
+}