@geminilight/mindos 0.6.73 → 0.6.74

package/_standalone/hooks/useFileImport.ts

@@ -1,233 +0,0 @@
-'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

@@ -1,206 +0,0 @@
-'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

@@ -1,153 +0,0 @@
-'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

@@ -1,81 +0,0 @@
-'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,
-  };
-}