@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/hooks/useFileImport.ts

@@ -0,0 +1,233 @@
+'use client';
+
+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' | 'organizing' | 'organize_review';
+export type ConflictMode = 'skip' | 'rename' | 'overwrite';
+
+export interface ImportFile {
+  file: File;
+  name: string;
+  size: number;
+  content: string | null;
+  loading: boolean;
+  error: string | null;
+}
+
+const MAX_FILE_SIZE = 5 * 1024 * 1024;
+const MAX_PDF_SIZE = 12 * 1024 * 1024;
+const MAX_FILES = 20;
+
+function getExt(name: string): string {
+  const idx = name.lastIndexOf('.');
+  return idx >= 0 ? name.slice(idx).toLowerCase() : '';
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  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?: 'success' | 'empty' | 'error'; extractionError?: string };
+  if (data.extracted === 'error') {
+    throw new Error(data.extractionError || 'Failed to parse PDF');
+  }
+  if (data.extracted !== 'success' || !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');
+  const [intent, setIntent] = useState<ImportIntent>('archive');
+  const [targetSpace, setTargetSpace] = useState('');
+  const [conflict, setConflict] = useState<ConflictMode>('rename');
+  const [importing, setImporting] = useState(false);
+  const [result, setResult] = useState<{
+    created: Array<{ original: string; path: string }>;
+    skipped: Array<{ name: string; reason: string }>;
+    errors: Array<{ name: string; error: string }>;
+    updatedFiles: string[];
+  } | null>(null);
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  const addFiles = useCallback(async (fileList: FileList | File[]) => {
+    const incoming = Array.from(fileList).slice(0, MAX_FILES);
+    const newFiles: ImportFile[] = [];
+
+    for (const file of incoming) {
+      const ext = getExt(file.name);
+      const maxSize = ext === '.pdf' ? MAX_PDF_SIZE : MAX_FILE_SIZE;
+
+      let error: string | null = null;
+      if (!ALLOWED_IMPORT_EXTENSIONS.has(ext)) {
+        error = 'unsupported';
+      } else if (file.size > maxSize) {
+        error = 'tooLarge';
+      }
+
+      newFiles.push({
+        file,
+        name: file.name,
+        size: file.size,
+        content: null,
+        loading: !error,
+        error,
+      });
+    }
+
+    setFiles(prev => {
+      const merged = [...prev];
+      for (const f of newFiles) {
+        const isDup = merged.some(m =>
+          m.name === f.name && m.size === f.size && m.file.lastModified === f.file.lastModified
+        );
+        if (!isDup && merged.length < MAX_FILES) merged.push(f);
+      }
+      return merged;
+    });
+
+    for (const f of newFiles) {
+      if (f.error) continue;
+      try {
+        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 }
+            : p
+        ));
+      } catch {
+        setFiles(prev => prev.map(p =>
+          p.name === f.name && p.size === f.size
+            ? { ...p, loading: false, error: 'readFailed' }
+            : p
+        ));
+      }
+    }
+  }, []);
+
+  const removeFile = useCallback((index: number) => {
+    setFiles(prev => prev.filter((_, i) => i !== index));
+  }, []);
+
+  const clearFiles = useCallback(() => {
+    setFiles([]);
+    setStep('select');
+    setResult(null);
+  }, []);
+
+  const validFiles = files.filter(f => !f.error && f.content !== null);
+  const allReady = files.length > 0 && files.every(f => !f.loading);
+  const hasErrors = files.some(f => f.error);
+
+  const doArchive = useCallback(async () => {
+    if (validFiles.length === 0) return;
+    setImporting(true);
+    setStep('importing');
+
+    try {
+      const payload = {
+        files: validFiles.map(f => ({
+          name: f.name,
+          content: f.content!,
+        })),
+        targetSpace: targetSpace || undefined,
+        conflict,
+        organize: true,
+      };
+
+      const res = await fetch('/api/file/import', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+
+      const data = await res.json();
+      if (!res.ok) throw new Error(data.error || `HTTP ${res.status}`);
+
+      setResult(data);
+      setStep('done');
+    } catch (err) {
+      setResult({
+        created: [],
+        skipped: [],
+        errors: [{ name: '*', error: (err as Error).message }],
+        updatedFiles: [],
+      });
+      setStep('done');
+    } finally {
+      setImporting(false);
+    }
+  }, [validFiles, targetSpace, conflict]);
+
+  const reset = useCallback(() => {
+    setFiles([]);
+    setStep('select');
+    setIntent('archive');
+    setTargetSpace('');
+    setConflict('rename');
+    setImporting(false);
+    setResult(null);
+  }, []);
+
+  return {
+    files,
+    step,
+    intent,
+    targetSpace,
+    conflict,
+    importing,
+    result,
+    inputRef,
+    validFiles,
+    allReady,
+    hasErrors,
+    addFiles,
+    removeFile,
+    clearFiles,
+    setStep,
+    setIntent,
+    setTargetSpace,
+    setConflict,
+    doArchive,
+    reset,
+    formatSize,
+  };
+}

package/_standalone/hooks/useFileUpload.ts

@@ -0,0 +1,206 @@
+'use client';
+
+import { useState, useCallback, useRef } from 'react';
+import type { LocalAttachment } from '@/lib/types';
+
+const ALLOWED_UPLOAD_EXTENSIONS = new Set([
+  '.txt', '.md', '.markdown', '.csv', '.json', '.yaml', '.yml', '.xml', '.html', '.htm', '.pdf',
+]);
+
+function getExt(name: string): string {
+  const idx = name.lastIndexOf('.');
+  return idx >= 0 ? name.slice(idx).toLowerCase() : '';
+}
+
+function uint8ToBase64(bytes: Uint8Array): string {
+  let binary = '';
+  const chunkSize = 0x8000;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    const chunk = bytes.subarray(i, i + chunkSize);
+    binary += String.fromCharCode(...chunk);
+  }
+  return btoa(binary);
+}
+
+async function extractPdfToAttachment(file: File): Promise<LocalAttachment> {
+  const name = file.name;
+
+  try {
+    const buffer = await file.arrayBuffer();
+    const dataBase64 = uint8ToBase64(new Uint8Array(buffer));
+
+    const res = await fetch('/api/extract-pdf', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name, dataBase64 }),
+    });
+
+    let payload: {
+      text?: string;
+      extracted?: 'success' | 'empty' | 'error';
+      extractionError?: string;
+      error?: string;
+      truncated?: boolean;
+      totalChars?: number;
+      pagesParsed?: number;
+    } = {};
+    try {
+      payload = await res.json();
+    } catch {
+      throw new Error('Failed to parse extraction response');
+    }
+
+    if (!res.ok) {
+      throw new Error(payload.error || `PDF extraction failed (${res.status})`);
+    }
+
+    // Handle extraction error state
+    if (payload.extracted === 'error') {
+      return {
+        name,
+        content: `[PDF: ${name}] Failed to extract text from this PDF.`,
+        status: 'error',
+        error: payload.extractionError || 'PDF extraction failed (unable to parse PDF)',
+      };
+    }
+
+    // Handle empty PDF (no extraction error, but no text)
+    const text = payload.extracted === 'success' ? (payload.text || '') : '';
+    if (!text) {
+      return {
+        name,
+        content: `[PDF: ${name}] Could not extract readable text (possibly scanned/image PDF).`,
+        status: 'error',
+        error: 'No extractable text found — PDF may be scanned, image-only, or have no text content',
+      };
+    }
+
+    const att: LocalAttachment = {
+      name,
+      content: `[PDF TEXT EXTRACTED: ${name}]\n\n${text}`,
+      status: 'success',
+    };
+
+    if (payload.truncated && payload.totalChars) {
+      att.truncatedInfo = {
+        totalChars: payload.totalChars,
+        includedChars: text.length,
+        totalPages: payload.pagesParsed ?? 0,
+      };
+    }
+
+    return att;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : 'Unknown error';
+    return {
+      name,
+      content: `[PDF: ${name}] Failed to extract text from this PDF.`,
+      status: 'error',
+      error: msg,
+    };
+  }
+}
+
+export interface FileUploadLabels {
+  unsupportedType?: string;
+}
+
+export function useFileUpload(labels?: FileUploadLabels) {
+  const [localAttachments, setLocalAttachments] = useState<LocalAttachment[]>([]);
+  const [uploadError, setUploadError] = useState('');
+  const uploadInputRef = useRef<HTMLInputElement>(null);
+
+  const labelsRef = useRef(labels);
+  labelsRef.current = labels;
+
+  const pickFiles = useCallback(async (files: FileList | null) => {
+    if (!files || files.length === 0) return;
+
+    const picked = Array.from(files).slice(0, 8);
+    const accepted: File[] = [];
+    const rejected: string[] = [];
+
+    for (const f of picked) {
+      const ext = getExt(f.name);
+      if (!ALLOWED_UPLOAD_EXTENSIONS.has(ext)) {
+        rejected.push(f.name);
+      } else {
+        accepted.push(f);
+      }
+    }
+
+    if (rejected.length > 0) {
+      const label = labelsRef.current?.unsupportedType ?? 'Unsupported file type';
+      setUploadError(`${label}: ${rejected.join(', ')}`);
+    } else {
+      setUploadError('');
+    }
+
+    // Phase 1: Immediately add all files — PDFs start in 'loading' state
+    const pdfFiles: File[] = [];
+    const immediateItems: LocalAttachment[] = [];
+
+    for (const f of accepted) {
+      if (getExt(f.name) === '.pdf') {
+        immediateItems.push({ name: f.name, content: '', status: 'loading' });
+        pdfFiles.push(f);
+      } else {
+        immediateItems.push({
+          name: f.name,
+          content: await f.text(),
+          status: 'success',
+        });
+      }
+    }
+
+    setLocalAttachments((prev) => {
+      const merged = [...prev];
+      for (const item of immediateItems) {
+        if (!merged.some((m) => m.name === item.name)) merged.push(item);
+      }
+      return merged;
+    });
+
+    // Phase 2: Extract PDFs in parallel, then update each one in-place
+    if (pdfFiles.length > 0) {
+      const results = await Promise.all(pdfFiles.map(extractPdfToAttachment));
+
+      setLocalAttachments((prev) =>
+        prev.map((att) => {
+          if (att.status !== 'loading') return att;
+          const result = results.find((r) => r.name === att.name);
+          return result ?? att;
+        }),
+      );
+    }
+  }, []);
+
+  const removeAttachment = useCallback((idx: number) => {
+    setLocalAttachments((prev) => prev.filter((_, i) => i !== idx));
+  }, []);
+
+  const clearAttachments = useCallback(() => {
+    setLocalAttachments([]);
+    setUploadError('');
+  }, []);
+
+  const injectFiles = useCallback((files: LocalAttachment[]) => {
+    setLocalAttachments(prev => {
+      const merged = [...prev];
+      for (const item of files) {
+        if (!merged.some(m => m.name === item.name)) merged.push(item);
+      }
+      return merged;
+    });
+  }, []);
+
+  return {
+    localAttachments,
+    uploadError,
+    uploadInputRef,
+    pickFiles,
+    removeAttachment,
+    clearAttachments,
+    injectFiles,
+  };
+}

package/_standalone/hooks/useImageUpload.ts

@@ -0,0 +1,153 @@
+'use client';
+
+import { useState, useCallback } from 'react';
+import type { ImagePart, ImageMimeType } from '@/lib/types';
+
+const ALLOWED_IMAGE_TYPES: Set<string> = new Set([
+  'image/png', 'image/jpeg', 'image/gif', 'image/webp',
+]);
+
+const MAX_IMAGE_SIZE = 5 * 1024 * 1024; // 5MB per image
+const MAX_IMAGES = 4;
+const MAX_DIMENSION = 1920; // Compress to this max width/height
+
+function isImageMimeType(type: string): type is ImageMimeType {
+  return ALLOWED_IMAGE_TYPES.has(type);
+}
+
+/** Compress image to JPEG if over size/dimension limits */
+async function compressImage(file: File): Promise<{ data: string; mimeType: ImageMimeType }> {
+  const mimeType = file.type as ImageMimeType;
+
+  // If small enough, use as-is (skip canvas compression to preserve GIF animation)
+  if (file.size <= MAX_IMAGE_SIZE) {
+    const buffer = await file.arrayBuffer();
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    const chunkSize = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+      binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+    }
+    return { data: btoa(binary), mimeType };
+  }
+
+  // Compress via canvas
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    const objectUrl = URL.createObjectURL(file);
+    img.onload = () => {
+      let { width, height } = img;
+      if (width > MAX_DIMENSION || height > MAX_DIMENSION) {
+        const ratio = Math.min(MAX_DIMENSION / width, MAX_DIMENSION / height);
+        width = Math.round(width * ratio);
+        height = Math.round(height * ratio);
+      }
+      const canvas = document.createElement('canvas');
+      canvas.width = width;
+      canvas.height = height;
+      const ctx = canvas.getContext('2d');
+      if (!ctx) { URL.revokeObjectURL(objectUrl); reject(new Error('Canvas not supported')); return; }
+      ctx.drawImage(img, 0, 0, width, height);
+      const dataUrl = canvas.toDataURL('image/jpeg', 0.85);
+      const base64 = dataUrl.split(',')[1];
+      URL.revokeObjectURL(objectUrl);
+      resolve({ data: base64, mimeType: 'image/jpeg' });
+    };
+    img.onerror = () => { URL.revokeObjectURL(objectUrl); reject(new Error('Failed to load image')); };
+    img.src = objectUrl;
+  });
+}
+
+/** Convert clipboard/DataTransfer items to File[] */
+function extractImageFiles(items: DataTransferItemList | DataTransferItem[]): File[] {
+  const files: File[] = [];
+  const list = Array.from(items);
+  for (const item of list) {
+    if (item.kind === 'file' && ALLOWED_IMAGE_TYPES.has(item.type)) {
+      const file = item.getAsFile();
+      if (file) files.push(file);
+    }
+  }
+  return files;
+}
+
+export function useImageUpload() {
+  const [images, setImages] = useState<ImagePart[]>([]);
+  const [imageError, setImageError] = useState('');
+
+  const addImages = useCallback(async (files: File[]) => {
+    setImageError('');
+    const toProcess = files.slice(0, MAX_IMAGES);
+
+    const results: ImagePart[] = [];
+    for (const file of toProcess) {
+      if (!isImageMimeType(file.type)) {
+        setImageError(`Unsupported image type: ${file.type}`);
+        continue;
+      }
+      try {
+        const { data, mimeType } = await compressImage(file);
+        results.push({ type: 'image', data, mimeType, fileName: file.name || undefined });
+      } catch {
+        setImageError(`Failed to process image: ${file.name}`);
+      }
+    }
+
+    setImages(prev => {
+      const merged = [...prev, ...results];
+      if (merged.length > MAX_IMAGES) {
+        setImageError(`Maximum ${MAX_IMAGES} images allowed`);
+        return merged.slice(0, MAX_IMAGES);
+      }
+      return merged;
+    });
+  }, []);
+
+  /** Handle paste event — returns true if images were found */
+  const handlePaste = useCallback(async (e: ClipboardEvent | React.ClipboardEvent): Promise<boolean> => {
+    const items = e.clipboardData?.items;
+    if (!items) return false;
+    const files = extractImageFiles(items);
+    if (files.length === 0) return false;
+    await addImages(files);
+    return true;
+  }, [addImages]);
+
+  /** Handle drop event */
+  const handleDrop = useCallback(async (e: DragEvent | React.DragEvent) => {
+    const items = e.dataTransfer?.items;
+    if (!items) return;
+    const files = extractImageFiles(items);
+    if (files.length > 0) {
+      e.preventDefault();
+      await addImages(files);
+    }
+  }, [addImages]);
+
+  /** Handle file input change */
+  const handleFileSelect = useCallback(async (files: FileList | null) => {
+    if (!files) return;
+    const imageFiles = Array.from(files).filter(f => isImageMimeType(f.type));
+    await addImages(imageFiles);
+  }, [addImages]);
+
+  const removeImage = useCallback((idx: number) => {
+    setImages(prev => prev.filter((_, i) => i !== idx));
+  }, []);
+
+  const clearImages = useCallback(() => {
+    setImages([]);
+    setImageError('');
+  }, []);
+
+  return {
+    images,
+    imageError,
+    addImages,
+    handlePaste,
+    handleDrop,
+    handleFileSelect,
+    removeImage,
+    clearImages,
+  };
+}

package/_standalone/hooks/useLeftPanel.ts

@@ -0,0 +1,81 @@
+'use client';
+
+import { useState, useEffect, useCallback } from 'react';
+import { MIN_PANEL_WIDTH, MAX_PANEL_WIDTH_ABS, PANEL_WIDTH } from '@/components/Panel';
+import type { PanelId } from '@/components/ActivityBar';
+import { RAIL_WIDTH_COLLAPSED, RAIL_WIDTH_EXPANDED } from '@/components/ActivityBar';
+
+export interface LeftPanelState {
+  activePanel: PanelId | null;
+  setActivePanel: (p: PanelId | null | ((prev: PanelId | null) => PanelId | null)) => void;
+  panelWidth: number | null;
+  panelMaximized: boolean;
+  railExpanded: boolean;
+  railWidth: number;
+  panelOpen: boolean;
+  effectivePanelWidth: number;
+  handlePanelWidthChange: (w: number) => void;
+  handlePanelWidthCommit: (w: number) => void;
+  handlePanelMaximize: () => void;
+  handleExpandedChange: (expanded: boolean) => void;
+}
+
+/**
+ * Manages left panel state: active panel, width, maximize, rail expansion.
+ * Extracted from SidebarLayout to reduce its state complexity.
+ */
+export function useLeftPanel(): LeftPanelState {
+  const [activePanel, setActivePanel] = useState<PanelId | null>('files');
+  const [panelWidth, setPanelWidth] = useState<number | null>(null);
+  const [panelMaximized, setPanelMaximized] = useState(false);
+  const [railExpanded, setRailExpanded] = useState(false);
+
+  // Load persisted rail state
+  useEffect(() => {
+    try {
+      if (localStorage.getItem('rail-expanded') === 'true') setRailExpanded(true);
+    } catch {}
+  }, []);
+
+  // Load persisted panel width when activePanel changes
+  useEffect(() => {
+    if (!activePanel) return;
+    try {
+      const stored = localStorage.getItem('left-panel-width');
+      if (stored) {
+        const w = parseInt(stored, 10);
+        if (w >= MIN_PANEL_WIDTH && w <= MAX_PANEL_WIDTH_ABS) {
+          setPanelWidth(w);
+          return;
+        }
+      }
+    } catch {}
+    setPanelWidth(280);
+  }, [activePanel]);
+
+  // Exit maximize when switching panels
+  useEffect(() => { setPanelMaximized(false); }, [activePanel]);
+
+  const handlePanelWidthChange = useCallback((w: number) => setPanelWidth(w), []);
+  const handlePanelWidthCommit = useCallback((w: number) => {
+    try { localStorage.setItem('left-panel-width', String(w)); } catch {}
+  }, []);
+  const handlePanelMaximize = useCallback(() => setPanelMaximized(v => !v), []);
+
+  const handleExpandedChange = useCallback((expanded: boolean) => {
+    setRailExpanded(expanded);
+    try { localStorage.setItem('rail-expanded', String(expanded)); } catch {}
+  }, []);
+
+  const railWidth = railExpanded ? RAIL_WIDTH_EXPANDED : RAIL_WIDTH_COLLAPSED;
+  const panelOpen = activePanel !== null;
+  const effectivePanelWidth = panelWidth ?? (activePanel ? PANEL_WIDTH[activePanel] : 280);
+
+  return {
+    activePanel, setActivePanel,
+    panelWidth, panelMaximized, railExpanded, railWidth,
+    panelOpen, effectivePanelWidth,
+    handlePanelWidthChange, handlePanelWidthCommit, handlePanelMaximize,
+    handleExpandedChange,
+  };
+}