@geminilight/mindos 0.6.7 → 0.6.12

package/app/hooks/useAiOrganize.ts

@@ -0,0 +1,450 @@
+'use client';
+
+import { useState, useCallback, useRef } from 'react';
+import type { LocalAttachment, Message } from '@/lib/types';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type OrganizePhase = 'idle' | 'organizing' | 'done' | 'error';
+
+export interface OrganizeFileChange {
+  action: 'create' | 'update' | 'unknown';
+  path: string;
+  toolCallId: string;
+  /** Whether the tool call completed successfully */
+  ok: boolean;
+  /** Marked true after user undoes this change */
+  undone?: boolean;
+}
+
+/** In-memory file snapshots captured before AI writes, keyed by path */
+export type FileSnapshots = Map<string, string>;
+
+/** User-facing stage hint derived from SSE events */
+export type OrganizeStageHint =
+  | 'connecting'
+  | 'analyzing'
+  | 'reading'
+  | 'thinking'
+  | 'writing';
+
+export interface AiOrganizeState {
+  phase: OrganizePhase;
+  changes: OrganizeFileChange[];
+  /** Current tool being executed (for live progress display) */
+  currentTool: { name: string; path: string } | null;
+  /** User-facing stage hint with optional context (e.g. file being read) */
+  stageHint: { stage: OrganizeStageHint; detail?: string } | null;
+  /** AI's text summary of what it did */
+  summary: string;
+  error: string | null;
+}
+
+// ---------------------------------------------------------------------------
+// SSE stream parser — extracts file operations from /api/ask stream
+// ---------------------------------------------------------------------------
+
+/**
+ * Strip model chain-of-thought tags that should never be shown to users.
+ * Covers <thinking>, <reasoning>, <scratchpad> per wiki/80-known-pitfalls.md.
+ * Handles both complete blocks and unclosed trailing tags (streaming).
+ */
+export function stripThinkingTags(text: string): string {
+  let cleaned = text.replace(/<(thinking|reasoning|scratchpad)>[\s\S]*?<\/\1>/gi, '');
+  cleaned = cleaned.replace(/<(?:thinking|reasoning|scratchpad)>[\s\S]*$/gi, '');
+  return cleaned.trim();
+}
+
+export const CLIENT_TRUNCATE_CHARS = 20_000;
+
+const FILE_WRITE_TOOLS = new Set([
+  'create_file', 'write_file', 'batch_create_files',
+  'append_to_file', 'insert_after_heading', 'update_section',
+  'edit_lines', 'delete_file', 'rename_file', 'move_file', 'append_csv',
+]);
+
+const FILE_READ_TOOLS = new Set([
+  'read_file', 'read_lines', 'search', 'list_files',
+]);
+
+/**
+ * Derive a user-facing stage hint from an SSE event.
+ * Returns null for events that don't change the stage (e.g. tool_end, done).
+ */
+export function deriveStageHint(
+  eventType: string,
+  toolName: string | undefined,
+  args: unknown,
+): { stage: OrganizeStageHint; detail?: string } | null {
+  if (eventType === 'text_delta') {
+    return { stage: 'analyzing' };
+  }
+  if (eventType === 'tool_start' && toolName) {
+    if (FILE_WRITE_TOOLS.has(toolName)) {
+      return { stage: 'writing', detail: extractPathFromArgs(toolName, args) || undefined };
+    }
+    if (FILE_READ_TOOLS.has(toolName)) {
+      const detail = (args && typeof args === 'object' && 'path' in args && typeof (args as Record<string, unknown>).path === 'string')
+        ? (args as Record<string, unknown>).path as string
+        : undefined;
+      return { stage: 'reading', detail };
+    }
+    return { stage: 'analyzing' };
+  }
+  return null;
+}
+
+function extractPathFromArgs(toolName: string, args: unknown): string {
+  if (!args || typeof args !== 'object') return '';
+  const a = args as Record<string, unknown>;
+  if (typeof a.path === 'string') return a.path;
+  if (typeof a.from_path === 'string') return a.from_path;
+  if (toolName === 'batch_create_files' && Array.isArray(a.files)) {
+    return (a.files as Array<{ path?: string }>)
+      .map(f => f.path ?? '')
+      .filter(Boolean)
+      .join(', ');
+  }
+  return '';
+}
+
+/**
+ * Fetch a file's current content for snapshot (best-effort, never throws).
+ * Returns empty string on failure — undo will be unavailable for that file.
+ */
+async function captureSnapshot(path: string): Promise<string> {
+  try {
+    const res = await fetch(`/api/file?path=${encodeURIComponent(path)}&op=read_file`);
+    if (!res.ok) return '';
+    const data = await res.json() as { content?: string };
+    return data.content ?? '';
+  } catch {
+    return '';
+  }
+}
+
+async function consumeOrganizeStream(
+  body: ReadableStream<Uint8Array>,
+  onProgress: (state: Partial<AiOrganizeState> & { summary?: string }) => void,
+  onSnapshot: (path: string, content: string) => void,
+  signal?: AbortSignal,
+): Promise<{ changes: OrganizeFileChange[]; summary: string; toolCallCount: number }> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  const changes: OrganizeFileChange[] = [];
+  const pendingTools = new Map<string, { name: string; path: string; action: 'create' | 'update' | 'unknown' }>();
+  let summary = '';
+  let toolCallCount = 0;
+  const snapshotted = new Set<string>();
+
+  try {
+    while (true) {
+      if (signal?.aborted) break;
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() ?? '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data:')) continue;
+        const jsonStr = trimmed.slice(5).trim();
+        if (!jsonStr) continue;
+
+        let event: Record<string, unknown>;
+        try { event = JSON.parse(jsonStr); } catch { continue; }
+
+        const type = event.type as string;
+
+        switch (type) {
+          case 'tool_start': {
+            const toolName = event.toolName as string;
+            const toolCallId = event.toolCallId as string;
+            const args = event.args;
+            toolCallCount++;
+
+            const hint = deriveStageHint(type, toolName, args);
+            if (hint) onProgress({ stageHint: hint });
+
+            if (FILE_WRITE_TOOLS.has(toolName)) {
+              const path = extractPathFromArgs(toolName, args);
+              let action: 'create' | 'update' | 'unknown' = 'update';
+              if (toolName === 'create_file' || toolName === 'batch_create_files') action = 'create';
+              else if (toolName === 'delete_file' || toolName === 'rename_file' || toolName === 'move_file') action = 'unknown';
+
+              // Capture snapshot for update operations (fire-and-forget)
+              if (action === 'update' && path && !snapshotted.has(path)) {
+                snapshotted.add(path);
+                captureSnapshot(path).then(content => {
+                  if (content) onSnapshot(path, content);
+                });
+              }
+
+              pendingTools.set(toolCallId, { name: toolName, path, action });
+              onProgress({ currentTool: { name: toolName, path } });
+            }
+            break;
+          }
+
+          case 'tool_end': {
+            const toolCallId = event.toolCallId as string;
+            const isError = !!event.isError;
+            const pending = pendingTools.get(toolCallId);
+            if (pending) {
+              if (pending.name === 'batch_create_files') {
+                for (const p of pending.path.split(', ').filter(Boolean)) {
+                  changes.push({ action: pending.action, path: p, toolCallId, ok: !isError });
+                }
+              } else {
+                changes.push({ action: pending.action, path: pending.path, toolCallId, ok: !isError });
+              }
+              pendingTools.delete(toolCallId);
+              onProgress({ changes: [...changes], currentTool: null });
+            }
+            break;
+          }
+
+          case 'text_delta': {
+            summary += (event.delta as string) ?? '';
+            onProgress({ stageHint: { stage: 'analyzing' }, summary: stripThinkingTags(summary) });
+            break;
+          }
+
+          case 'error': {
+            throw new Error((event.message as string) || 'AI organize failed');
+          }
+
+          case 'done':
+            break;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  return { changes, summary: stripThinkingTags(summary), toolCallCount };
+}
+
+// ---------------------------------------------------------------------------
+// Hook
+// ---------------------------------------------------------------------------
+
+export function useAiOrganize() {
+  const [phase, setPhase] = useState<OrganizePhase>('idle');
+  const [changes, setChanges] = useState<OrganizeFileChange[]>([]);
+  const [currentTool, setCurrentTool] = useState<{ name: string; path: string } | null>(null);
+  const [stageHint, setStageHint] = useState<{ stage: OrganizeStageHint; detail?: string } | null>(null);
+  const [summary, setSummary] = useState('');
+  const [error, setError] = useState<string | null>(null);
+  const [toolCallCount, setToolCallCount] = useState(0);
+  const abortRef = useRef<AbortController | null>(null);
+  const lastEventRef = useRef<number>(0);
+  const snapshotsRef = useRef<FileSnapshots>(new Map());
+  const [sourceFileNames, setSourceFileNames] = useState<string[]>([]);
+
+  const start = useCallback(async (files: LocalAttachment[], prompt: string) => {
+    setPhase('organizing');
+    setChanges([]);
+    setCurrentTool(null);
+    setStageHint({ stage: 'connecting' });
+    setSummary('');
+    setError(null);
+    setToolCallCount(0);
+    setSourceFileNames(files.map(f => f.name));
+    snapshotsRef.current = new Map();
+    lastEventRef.current = Date.now();
+
+    const controller = new AbortController();
+    abortRef.current = controller;
+
+    const messages: Message[] = [{ role: 'user', content: prompt }];
+
+    const truncatedFiles = files.map(f => ({
+      name: f.name,
+      content: f.content.length > CLIENT_TRUNCATE_CHARS
+        ? f.content.slice(0, CLIENT_TRUNCATE_CHARS) + '\n\n[...truncated to first ~20000 chars]'
+        : f.content,
+    }));
+
+    try {
+      const res = await fetch('/api/ask', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          messages,
+          uploadedFiles: truncatedFiles,
+          maxSteps: 15,
+        }),
+        signal: controller.signal,
+      });
+
+      if (!res.ok) {
+        let errorMsg = `Request failed (${res.status})`;
+        try {
+          const errBody = await res.json() as { error?: { message?: string } | string; message?: string };
+          if (typeof errBody?.error === 'string') errorMsg = errBody.error;
+          else if (typeof errBody?.error === 'object' && errBody.error?.message) errorMsg = errBody.error.message;
+          else if (errBody?.message) errorMsg = errBody.message as string;
+        } catch {}
+        throw new Error(errorMsg);
+      }
+
+      if (!res.body) throw new Error('No response body');
+
+      const result = await consumeOrganizeStream(
+        res.body,
+        (partial) => {
+          lastEventRef.current = Date.now();
+          if (partial.changes) setChanges(partial.changes);
+          if (partial.currentTool !== undefined) setCurrentTool(partial.currentTool);
+          if (partial.stageHint) setStageHint(partial.stageHint);
+          if (partial.summary !== undefined) setSummary(partial.summary);
+        },
+        (path, content) => {
+          snapshotsRef.current.set(path, content);
+        },
+        controller.signal,
+      );
+
+      setChanges(result.changes);
+      setSummary(result.summary);
+      setToolCallCount(result.toolCallCount);
+      setCurrentTool(null);
+      setPhase('done');
+    } catch (err) {
+      if ((err as Error).name === 'AbortError') {
+        setPhase('idle');
+      } else {
+        setError((err as Error).message);
+        setPhase('error');
+      }
+    } finally {
+      abortRef.current = null;
+    }
+  }, []);
+
+  const abort = useCallback(() => {
+    abortRef.current?.abort();
+  }, []);
+
+  /** Undo a single file change — supports both create (delete) and update (restore snapshot) */
+  const undoOne = useCallback(async (path: string): Promise<boolean> => {
+    const target = changes.find(c => c.path === path && c.ok && !c.undone);
+    if (!target) return false;
+
+    try {
+      if (target.action === 'create') {
+        const res = await fetch('/api/file', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ op: 'delete_file', path: target.path }),
+        });
+        if (!res.ok) return false;
+      } else if (target.action === 'update') {
+        const snapshot = snapshotsRef.current.get(path);
+        if (!snapshot) return false;
+        const res = await fetch('/api/file', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ op: 'write_file', path: target.path, content: snapshot }),
+        });
+        if (!res.ok) return false;
+      } else {
+        return false;
+      }
+
+      setChanges(prev => prev.map(c =>
+        c.path === path && c.ok && !c.undone ? { ...c, undone: true } : c,
+      ));
+      return true;
+    } catch {
+      return false;
+    }
+  }, [changes]);
+
+  const undoAll = useCallback(async (): Promise<number> => {
+    const undoable = changes.filter(c => c.ok && !c.undone && (c.action === 'create' || (c.action === 'update' && snapshotsRef.current.has(c.path))));
+    let reverted = 0;
+    for (const file of undoable) {
+      try {
+        if (file.action === 'create') {
+          const res = await fetch('/api/file', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ op: 'delete_file', path: file.path }),
+          });
+          if (res.ok) reverted++;
+        } else if (file.action === 'update') {
+          const snapshot = snapshotsRef.current.get(file.path);
+          if (snapshot) {
+            const res = await fetch('/api/file', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({ op: 'write_file', path: file.path, content: snapshot }),
+            });
+            if (res.ok) reverted++;
+          }
+        }
+      } catch {}
+    }
+    if (reverted > 0) {
+      setChanges(prev => prev.map(c => {
+        if (!c.ok || c.undone) return c;
+        if (c.action === 'create') return { ...c, undone: true };
+        if (c.action === 'update' && snapshotsRef.current.has(c.path)) return { ...c, undone: true };
+        return c;
+      }));
+    }
+    return reverted;
+  }, [changes]);
+
+  /** Check if a specific file can be undone */
+  const canUndo = useCallback((path: string): boolean => {
+    const c = changes.find(ch => ch.path === path && ch.ok && !ch.undone);
+    if (!c) return false;
+    if (c.action === 'create') return true;
+    if (c.action === 'update') return snapshotsRef.current.has(path);
+    return false;
+  }, [changes]);
+
+  const hasAnyUndoable = changes.some(c => c.ok && !c.undone && (c.action === 'create' || (c.action === 'update' && snapshotsRef.current.has(c.path))));
+
+  const reset = useCallback(() => {
+    setPhase('idle');
+    setChanges([]);
+    setCurrentTool(null);
+    setStageHint(null);
+    setSummary('');
+    setError(null);
+    setToolCallCount(0);
+    setSourceFileNames([]);
+    snapshotsRef.current = new Map();
+    lastEventRef.current = 0;
+  }, []);
+
+  return {
+    phase,
+    changes,
+    currentTool,
+    stageHint,
+    summary,
+    error,
+    toolCallCount,
+    sourceFileNames,
+    snapshots: snapshotsRef,
+    start,
+    abort,
+    undoOne,
+    undoAll,
+    canUndo,
+    hasAnyUndoable,
+    reset,
+  };
+}

package/app/hooks/useFileImport.ts

@@ -4,7 +4,7 @@ import { useState, useCallback, useRef } from 'react';
 import { ALLOWED_IMPORT_EXTENSIONS } from '@/lib/core/file-convert';
 
 export type ImportIntent = 'archive' | 'digest';
-export type ImportStep = 'select' | 'archive_config' | 'importing' | 'done';
+export type ImportStep = 'select' | 'archive_config' | 'importing' | 'done' | 'organizing' | 'organize_review';
 export type ConflictMode = 'skip' | 'rename' | 'overwrite';
 
 export interface ImportFile {
@@ -31,6 +31,37 @@ function formatSize(bytes: number): string {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 
+function fileToBase64(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const dataUrl = reader.result as string;
+      const commaIdx = dataUrl.indexOf(',');
+      resolve(commaIdx >= 0 ? dataUrl.slice(commaIdx + 1) : '');
+    };
+    reader.onerror = () => reject(reader.error ?? new Error('FileReader error'));
+    reader.readAsDataURL(file);
+  });
+}
+
+async function extractPdfText(file: File): Promise<string> {
+  const base64 = await fileToBase64(file);
+  if (!base64) throw new Error('Empty PDF file');
+
+  const res = await fetch('/api/extract-pdf', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name: file.name, dataBase64: base64 }),
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error((err as { error?: string }).error || 'PDF extraction failed');
+  }
+  const data = await res.json() as { text?: string; extracted?: boolean };
+  if (!data.extracted || !data.text) throw new Error('No text extracted from PDF');
+  return data.text;
+}
+
 export function useFileImport() {
   const [files, setFiles] = useState<ImportFile[]>([]);
   const [step, setStep] = useState<ImportStep>('select');
@@ -85,7 +116,13 @@ export function useFileImport() {
     for (const f of newFiles) {
       if (f.error) continue;
       try {
-        const text = await f.file.text();
+        const ext = getExt(f.name);
+        let text: string;
+        if (ext === '.pdf') {
+          text = await extractPdfText(f.file);
+        } else {
+          text = await f.file.text();
+        }
         setFiles(prev => prev.map(p =>
           p.name === f.name && p.size === f.size
             ? { ...p, content: text, loading: false }

package/app/hooks/useMention.ts

@@ -47,15 +47,33 @@ export function useMention() {
         return;
       }
       const q = query.toLowerCase();
-      const filtered = allFiles.filter((f) => f.toLowerCase().includes(q)).slice(0, 30);
-      if (filtered.length === 0) {
+      if (!q) {
+        setMentionQuery(query);
+        setMentionResults(allFiles.slice(0, 30));
+        setMentionIndex(0);
+        return;
+      }
+      const scored = allFiles
+        .map((f) => {
+          const name = (f.split('/').pop() ?? f).toLowerCase();
+          const fl = f.toLowerCase();
+          let score = 0;
+          if (name.startsWith(q)) score = 100;
+          else if (name.includes(q)) score = 50;
+          else if (fl.includes(q)) score = 10;
+          return { path: f, score };
+        })
+        .filter((x) => x.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, 30);
+      if (scored.length === 0) {
         setMentionQuery(null);
         setMentionResults([]);
         setMentionIndex(0);
         return;
       }
       setMentionQuery(query);
-      setMentionResults(filtered);
+      setMentionResults(scored.map((x) => x.path));
       setMentionIndex(0);
     },
     [allFiles],

package/app/hooks/useSlashCommand.ts

@@ -66,10 +66,24 @@ export function useSlashCommand() {
       }
 
       const q = query.toLowerCase();
-      const items: SlashItem[] = allSkills
-        .filter((s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q))
-        .slice(0, 20)
-        .map((s) => ({ type: 'skill', name: s.name, description: s.description }));
+      const items: SlashItem[] = (q
+        ? allSkills
+            .map((s) => {
+              const nl = s.name.toLowerCase();
+              let score = 0;
+              if (nl.startsWith(q)) score = 100;
+              else if (nl.includes(q)) score = 50;
+              else if (s.description.toLowerCase().includes(q)) score = 10;
+              return { s, score };
+            })
+            .filter((x) => x.score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 20)
+            .map((x) => ({ type: 'skill' as const, name: x.s.name, description: x.s.description }))
+        : allSkills
+            .slice(0, 20)
+            .map((s) => ({ type: 'skill' as const, name: s.name, description: s.description }))
+      );
 
       if (items.length === 0) {
         setSlashQuery(null);

package/app/lib/agent/reconnect.ts

@@ -0,0 +1,40 @@
+/** Auto-reconnect utilities for Ask AI streaming connections. */
+
+const NON_RETRYABLE_STATUS = new Set([401, 403, 429]);
+
+const NON_RETRYABLE_PATTERNS = [
+  /api.?key/i,
+  /model.*not.?found/i,
+  /authentication/i,
+  /unauthorized/i,
+  /forbidden/i,
+];
+
+export function isRetryableError(err: unknown, httpStatus?: number): boolean {
+  if (err instanceof DOMException && err.name === 'AbortError') return false;
+  if (httpStatus && NON_RETRYABLE_STATUS.has(httpStatus)) return false;
+
+  if (err instanceof Error) {
+    const msg = err.message;
+    if (NON_RETRYABLE_PATTERNS.some(p => p.test(msg))) return false;
+  }
+
+  return true;
+}
+
+const BASE_DELAY = 1000;
+const MAX_DELAY = 10_000;
+
+/** Exponential backoff: 1s, 2s, 4s, 8s... capped at 10s */
+export function retryDelay(attempt: number): number {
+  return Math.min(BASE_DELAY * 2 ** attempt, MAX_DELAY);
+}
+
+export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const abortReason = () => signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError');
+    if (signal?.aborted) { reject(abortReason()); return; }
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener('abort', () => { clearTimeout(timer); reject(abortReason()); }, { once: true });
+  });
+}

package/app/lib/core/backlinks.ts

@@ -7,8 +7,8 @@ import type { BacklinkEntry } from './types';
  * Finds files that reference the given targetPath via wikilinks,
  * markdown links, or backtick references.
  */
-export function findBacklinks(mindRoot: string, targetPath: string): BacklinkEntry[] {
-  const allFiles = collectAllFiles(mindRoot).filter(f => f.endsWith('.md') && f !== targetPath);
+export function findBacklinks(mindRoot: string, targetPath: string, cachedFiles?: string[]): BacklinkEntry[] {
+  const allFiles = (cachedFiles ?? collectAllFiles(mindRoot)).filter(f => f.endsWith('.md') && f !== targetPath);
   const results: BacklinkEntry[] = [];
   const bname = path.basename(targetPath, '.md');
   const escapedTarget = targetPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

package/app/lib/core/git.ts

@@ -1,4 +1,4 @@
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { resolveSafe } from './security';
 import type { GitLogEntry } from './types';
 
@@ -7,7 +7,7 @@ import type { GitLogEntry } from './types';
  */
 export function isGitRepo(mindRoot: string): boolean {
   try {
-    execSync('git rev-parse --is-inside-work-tree', { cwd: mindRoot, stdio: 'pipe' });
+    execFileSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: mindRoot, stdio: 'pipe' });
     return true;
   } catch { return false; }
 }
@@ -17,8 +17,9 @@ export function isGitRepo(mindRoot: string): boolean {
  */
 export function gitLog(mindRoot: string, filePath: string, limit: number): GitLogEntry[] {
   const resolved = resolveSafe(mindRoot, filePath);
-  const output = execSync(
-    `git log --follow --format="%H%x00%aI%x00%s%x00%an" -n ${limit} -- "${resolved}"`,
+  const output = execFileSync(
+    'git',
+    ['log', '--follow', '--format=%H%x00%aI%x00%s%x00%an', '-n', String(limit), '--', resolved],
     { cwd: mindRoot, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
   ).trim();
   if (!output) return [];
@@ -33,18 +34,21 @@ export function gitLog(mindRoot: string, filePath: string, limit: number): GitLo
  */
 export function gitShowFile(mindRoot: string, filePath: string, commitHash: string): string {
   const resolved = resolveSafe(mindRoot, filePath);
-  const relFromGitRoot = execSync(
-    `git ls-files --full-name "${resolved}"`,
+  const relFromGitRoot = execFileSync(
+    'git',
+    ['ls-files', '--full-name', resolved],
     { cwd: mindRoot, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
   ).trim();
   if (!relFromGitRoot) {
-    return execSync(
-      `git show ${commitHash}:"${filePath}"`,
+    return execFileSync(
+      'git',
+      ['show', `${commitHash}:${filePath}`],
       { cwd: mindRoot, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
     );
   }
-  return execSync(
-    `git show ${commitHash}:"${relFromGitRoot}"`,
+  return execFileSync(
+    'git',
+    ['show', `${commitHash}:${relFromGitRoot}`],
     { cwd: mindRoot, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
   );
 }