@geminilight/mindos 0.1.0

package/app/components/ui/toggle.tsx

@@ -0,0 +1,44 @@
+"use client"
+
+import { Toggle as TogglePrimitive } from "@base-ui/react/toggle"
+import { cva, type VariantProps } from "class-variance-authority"
+
+import { cn } from "@/lib/utils"
+
+const toggleVariants = cva(
+  "group/toggle inline-flex items-center justify-center gap-1 rounded-lg text-sm font-medium whitespace-nowrap transition-all outline-none hover:bg-muted hover:text-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 aria-pressed:bg-muted data-[state=on]:bg-muted dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+  {
+    variants: {
+      variant: {
+        default: "bg-transparent",
+        outline: "border border-input bg-transparent hover:bg-muted",
+      },
+      size: {
+        default: "h-8 min-w-8 px-2",
+        sm: "h-7 min-w-7 rounded-[min(var(--radius-md),12px)] px-1.5 text-[0.8rem]",
+        lg: "h-9 min-w-9 px-2.5",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  }
+)
+
+function Toggle({
+  className,
+  variant = "default",
+  size = "default",
+  ...props
+}: TogglePrimitive.Props & VariantProps<typeof toggleVariants>) {
+  return (
+    <TogglePrimitive
+      data-slot="toggle"
+      className={cn(toggleVariants({ variant, size, className }))}
+      {...props}
+    />
+  )
+}
+
+export { Toggle, toggleVariants }

package/app/components/ui/tooltip.tsx

@@ -0,0 +1,66 @@
+"use client"
+
+import { Tooltip as TooltipPrimitive } from "@base-ui/react/tooltip"
+
+import { cn } from "@/lib/utils"
+
+function TooltipProvider({
+  delay = 0,
+  ...props
+}: TooltipPrimitive.Provider.Props) {
+  return (
+    <TooltipPrimitive.Provider
+      data-slot="tooltip-provider"
+      delay={delay}
+      {...props}
+    />
+  )
+}
+
+function Tooltip({ ...props }: TooltipPrimitive.Root.Props) {
+  return <TooltipPrimitive.Root data-slot="tooltip" {...props} />
+}
+
+function TooltipTrigger({ ...props }: TooltipPrimitive.Trigger.Props) {
+  return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />
+}
+
+function TooltipContent({
+  className,
+  side = "top",
+  sideOffset = 4,
+  align = "center",
+  alignOffset = 0,
+  children,
+  ...props
+}: TooltipPrimitive.Popup.Props &
+  Pick<
+    TooltipPrimitive.Positioner.Props,
+    "align" | "alignOffset" | "side" | "sideOffset"
+  >) {
+  return (
+    <TooltipPrimitive.Portal>
+      <TooltipPrimitive.Positioner
+        align={align}
+        alignOffset={alignOffset}
+        side={side}
+        sideOffset={sideOffset}
+        className="isolate z-50"
+      >
+        <TooltipPrimitive.Popup
+          data-slot="tooltip-content"
+          className={cn(
+            "z-50 inline-flex w-fit max-w-xs origin-(--transform-origin) items-center gap-1.5 rounded-md bg-foreground px-3 py-1.5 text-xs text-background has-data-[slot=kbd]:pr-1.5 data-[side=bottom]:slide-in-from-top-2 data-[side=inline-end]:slide-in-from-left-2 data-[side=inline-start]:slide-in-from-right-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 **:data-[slot=kbd]:relative **:data-[slot=kbd]:isolate **:data-[slot=kbd]:z-50 **:data-[slot=kbd]:rounded-sm data-[state=delayed-open]:animate-in data-[state=delayed-open]:fade-in-0 data-[state=delayed-open]:zoom-in-95 data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95",
+            className
+          )}
+          {...props}
+        >
+          {children}
+          <TooltipPrimitive.Arrow className="z-50 size-2.5 translate-y-[calc(-50%-2px)] rotate-45 rounded-[2px] bg-foreground fill-foreground data-[side=bottom]:top-1 data-[side=inline-end]:top-1/2! data-[side=inline-end]:-left-1 data-[side=inline-end]:-translate-y-1/2 data-[side=inline-start]:top-1/2! data-[side=inline-start]:-right-1 data-[side=inline-start]:-translate-y-1/2 data-[side=left]:top-1/2! data-[side=left]:-right-1 data-[side=left]:-translate-y-1/2 data-[side=right]:top-1/2! data-[side=right]:-left-1 data-[side=right]:-translate-y-1/2 data-[side=top]:-bottom-2.5" />
+        </TooltipPrimitive.Popup>
+      </TooltipPrimitive.Positioner>
+    </TooltipPrimitive.Portal>
+  )
+}
+
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }

package/app/components.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "base-nova",
+  "rsc": true,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "app/globals.css",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "lucide",
+  "rtl": false,
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "menuColor": "default",
+  "menuAccent": "subtle",
+  "registries": {}
+}

package/app/eslint.config.mjs

@@ -0,0 +1,18 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    ".next/**",
+    "out/**",
+    "build/**",
+    "next-env.d.ts",
+  ]),
+]);
+
+export default eslintConfig;

package/app/hooks/useAskSession.ts

@@ -0,0 +1,181 @@
+'use client';
+
+import { useState, useCallback, useRef } from 'react';
+import type { Message, ChatSession } from '@/lib/types';
+import { apiFetch } from '@/lib/api';
+
+const MAX_SESSIONS = 30;
+
+function createSession(currentFile?: string): ChatSession {
+  const ts = Date.now();
+  return {
+    id: `${ts}-${Math.random().toString(36).slice(2, 8)}`,
+    currentFile,
+    createdAt: ts,
+    updatedAt: ts,
+    messages: [],
+  };
+}
+
+export function sessionTitle(s: ChatSession): string {
+  const firstUser = s.messages.find((m) => m.role === 'user');
+  if (!firstUser) return '(empty session)';
+  const line = firstUser.content.replace(/\s+/g, ' ').trim();
+  return line.length > 42 ? `${line.slice(0, 42)}...` : line;
+}
+
+async function fetchSessions(): Promise<ChatSession[]> {
+  try {
+    const res = await fetch('/api/ask-sessions', { cache: 'no-store' });
+    if (!res.ok) return [];
+    const data = (await res.json()) as ChatSession[];
+    if (!Array.isArray(data)) return [];
+    return data.slice(0, MAX_SESSIONS);
+  } catch {
+    return [];
+  }
+}
+
+async function upsertSession(session: ChatSession): Promise<void> {
+  try {
+    await fetch('/api/ask-sessions', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ session }),
+    });
+  } catch {
+    // ignore persistence errors
+  }
+}
+
+async function removeSession(id: string): Promise<void> {
+  try {
+    await fetch('/api/ask-sessions', {
+      method: 'DELETE',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ id }),
+    });
+  } catch {
+    // ignore persistence errors
+  }
+}
+
+export function useAskSession(currentFile?: string) {
+  const [messages, setMessages] = useState<Message[]>([]);
+  const [sessions, setSessions] = useState<ChatSession[]>([]);
+  const [activeSessionId, setActiveSessionId] = useState<string | null>(null);
+  const persistTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  /** Load sessions from server, pick the matching one or create fresh. */
+  const initSessions = useCallback(async () => {
+    const sorted = (await fetchSessions())
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+      .slice(0, MAX_SESSIONS);
+    setSessions(sorted);
+
+    const matched = currentFile
+      ? sorted.find((sess) => sess.currentFile === currentFile)
+      : sorted[0];
+
+    if (matched) {
+      setActiveSessionId(matched.id);
+      setMessages(matched.messages);
+    } else {
+      const fresh = createSession(currentFile);
+      setActiveSessionId(fresh.id);
+      setMessages([]);
+      const next = [fresh, ...sorted].slice(0, MAX_SESSIONS);
+      setSessions(next);
+      await upsertSession(fresh);
+    }
+  }, [currentFile]);
+
+  /** Persist current session (debounced). */
+  const persistSession = useCallback(
+    (msgs: Message[], sessionId: string | null) => {
+      if (!sessionId) return;
+      let sessionToPersist: ChatSession | null = null;
+      setSessions((prev) => {
+        const now = Date.now();
+        const existing = prev.find((s) => s.id === sessionId);
+        sessionToPersist = existing
+          ? { ...existing, currentFile, updatedAt: now, messages: msgs }
+          : { id: sessionId, currentFile, createdAt: now, updatedAt: now, messages: msgs };
+
+        const rest = prev.filter((s) => s.id !== sessionId);
+        return [sessionToPersist!, ...rest]
+          .sort((a, b) => b.updatedAt - a.updatedAt)
+          .slice(0, MAX_SESSIONS);
+      });
+
+      if (persistTimerRef.current) clearTimeout(persistTimerRef.current);
+      persistTimerRef.current = setTimeout(() => {
+        if (sessionToPersist) void upsertSession(sessionToPersist);
+      }, 600);
+    },
+    [currentFile],
+  );
+
+  const clearPersistTimer = useCallback(() => {
+    if (persistTimerRef.current) {
+      clearTimeout(persistTimerRef.current);
+      persistTimerRef.current = null;
+    }
+  }, []);
+
+  /** Create a brand-new session. */
+  const resetSession = useCallback(() => {
+    const fresh = createSession(currentFile);
+    setActiveSessionId(fresh.id);
+    setMessages([]);
+    setSessions((prev) => {
+      const next = [fresh, ...prev]
+        .sort((a, b) => b.updatedAt - a.updatedAt)
+        .slice(0, MAX_SESSIONS);
+      void upsertSession(fresh);
+      return next;
+    });
+  }, [currentFile]);
+
+  /** Switch to an existing session. */
+  const loadSession = useCallback(
+    (id: string) => {
+      const target = sessions.find((s) => s.id === id);
+      if (!target) return;
+      setActiveSessionId(target.id);
+      setMessages(target.messages);
+    },
+    [sessions],
+  );
+
+  /** Delete a session. If it's the active one, create fresh. */
+  const deleteSession = useCallback(
+    (id: string) => {
+      void removeSession(id);
+      const remaining = sessions.filter((s) => s.id !== id);
+      setSessions(remaining);
+
+      if (activeSessionId === id) {
+        const fresh = createSession(currentFile);
+        setActiveSessionId(fresh.id);
+        setMessages([]);
+        setSessions([fresh, ...remaining].slice(0, MAX_SESSIONS));
+        void upsertSession(fresh);
+      }
+    },
+    [activeSessionId, currentFile, sessions],
+  );
+
+  return {
+    messages,
+    setMessages,
+    sessions,
+    activeSessionId,
+    initSessions,
+    persistSession,
+    clearPersistTimer,
+    resetSession,
+    loadSession,
+    deleteSession,
+  };
+}

package/app/hooks/useFileUpload.ts

@@ -0,0 +1,126 @@
+'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 extractPdfText(file: File): Promise<string> {
+  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: file.name, dataBase64 }),
+  });
+
+  let payload: { text?: string; extracted?: boolean; error?: string } = {};
+  try {
+    payload = await res.json();
+  } catch {
+    // ignore JSON parse error
+  }
+
+  if (!res.ok) {
+    throw new Error(payload.error || `PDF extraction failed (${res.status})`);
+  }
+
+  return payload.extracted ? (payload.text || '') : '';
+}
+
+export function useFileUpload() {
+  const [localAttachments, setLocalAttachments] = useState<LocalAttachment[]>([]);
+  const [uploadError, setUploadError] = useState('');
+  const uploadInputRef = useRef<HTMLInputElement>(null);
+
+  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) {
+      setUploadError(`Unsupported file type: ${rejected.join(', ')}`);
+    } else {
+      setUploadError('');
+    }
+
+    const loaded = await Promise.all(
+      accepted.map(async (f) => {
+        const ext = getExt(f.name);
+        if (ext === '.pdf') {
+          try {
+            const extracted = await extractPdfText(f);
+            return {
+              name: f.name,
+              content: extracted
+                ? `[PDF TEXT EXTRACTED: ${f.name}]\n\n${extracted}`
+                : `[PDF: ${f.name}] Could not extract readable text (possibly scanned/image PDF).`,
+            };
+          } catch {
+            return {
+              name: f.name,
+              content: `[PDF: ${f.name}] Failed to extract text from this PDF.`,
+            };
+          }
+        }
+        return { name: f.name, content: await f.text() };
+      }),
+    );
+
+    setLocalAttachments((prev) => {
+      const merged = [...prev];
+      for (const item of loaded) {
+        if (!merged.some((m) => m.name === item.name && m.content === item.content))
+          merged.push(item);
+      }
+      return merged;
+    });
+  }, []);
+
+  const removeAttachment = useCallback((idx: number) => {
+    setLocalAttachments((prev) => prev.filter((_, i) => i !== idx));
+  }, []);
+
+  const clearAttachments = useCallback(() => {
+    setLocalAttachments([]);
+    setUploadError('');
+  }, []);
+
+  return {
+    localAttachments,
+    uploadError,
+    uploadInputRef,
+    pickFiles,
+    removeAttachment,
+    clearAttachments,
+  };
+}

package/app/hooks/useMention.ts

@@ -0,0 +1,65 @@
+'use client';
+
+import { useState, useCallback, useEffect } from 'react';
+
+export function useMention() {
+  const [allFiles, setAllFiles] = useState<string[]>([]);
+  const [mentionQuery, setMentionQuery] = useState<string | null>(null);
+  const [mentionResults, setMentionResults] = useState<string[]>([]);
+  const [mentionIndex, setMentionIndex] = useState(0);
+
+  // Load file list once
+  useEffect(() => {
+    fetch('/api/files')
+      .then((r) => r.json())
+      .then(setAllFiles)
+      .catch(() => {});
+  }, []);
+
+  /** Parse @-mention from input text; returns updated input if a mention was selected. */
+  const updateMentionFromInput = useCallback(
+    (val: string) => {
+      const atIdx = val.lastIndexOf('@');
+      if (atIdx === -1) {
+        setMentionQuery(null);
+        return;
+      }
+      const before = val[atIdx - 1];
+      if (atIdx > 0 && before !== ' ') {
+        setMentionQuery(null);
+        return;
+      }
+      const query = val.slice(atIdx + 1).toLowerCase();
+      setMentionQuery(query);
+      setMentionResults(allFiles.filter((f) => f.toLowerCase().includes(query)).slice(0, 8));
+      setMentionIndex(0);
+    },
+    [allFiles],
+  );
+
+  const navigateMention = useCallback(
+    (direction: 'up' | 'down') => {
+      if (direction === 'down') {
+        setMentionIndex((i) => Math.min(i + 1, mentionResults.length - 1));
+      } else {
+        setMentionIndex((i) => Math.max(i - 1, 0));
+      }
+    },
+    [mentionResults.length],
+  );
+
+  const resetMention = useCallback(() => {
+    setMentionQuery(null);
+    setMentionResults([]);
+    setMentionIndex(0);
+  }, []);
+
+  return {
+    mentionQuery,
+    mentionResults,
+    mentionIndex,
+    updateMentionFromInput,
+    navigateMention,
+    resetMention,
+  };
+}

package/app/lib/LocaleContext.tsx

@@ -0,0 +1,40 @@
+'use client';
+
+import { createContext, useContext, useState, useEffect, ReactNode } from 'react';
+import { Locale, messages, Messages } from './i18n';
+
+interface LocaleContextValue {
+  locale: Locale;
+  setLocale: (l: Locale) => void;
+  t: Messages;
+}
+
+const LocaleContext = createContext<LocaleContextValue>({
+  locale: 'en',
+  setLocale: () => {},
+  t: messages['en'],
+});
+
+export function LocaleProvider({ children }: { children: ReactNode }) {
+  const [locale, setLocaleState] = useState<Locale>('en');
+
+  useEffect(() => {
+    const saved = localStorage.getItem('locale') as Locale | null;
+    if (saved === 'zh' || saved === 'en') setLocaleState(saved);
+  }, []);
+
+  const setLocale = (l: Locale) => {
+    setLocaleState(l);
+    localStorage.setItem('locale', l);
+  };
+
+  return (
+    <LocaleContext.Provider value={{ locale, setLocale, t: messages[locale] as unknown as Messages }}>
+      {children}
+    </LocaleContext.Provider>
+  );
+}
+
+export function useLocale() {
+  return useContext(LocaleContext);
+}

package/app/lib/actions.ts

@@ -0,0 +1,40 @@
+'use server';
+
+import { createFile, deleteFile, renameFile } from '@/lib/fs';
+import { revalidatePath } from 'next/cache';
+
+export async function createFileAction(dirPath: string, fileName: string): Promise<{ success: boolean; filePath?: string; error?: string }> {
+  try {
+    const name = fileName.trim();
+    if (!name) return { success: false, error: 'File name is required' };
+    // Ensure extension
+    const hasExt = name.endsWith('.md') || name.endsWith('.csv');
+    const finalName = hasExt ? name : `${name}.md`;
+    const filePath = dirPath ? `${dirPath}/${finalName}` : finalName;
+    createFile(filePath);
+    revalidatePath('/', 'layout');
+    return { success: true, filePath };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to create file' };
+  }
+}
+
+export async function deleteFileAction(filePath: string): Promise<{ success: boolean; error?: string }> {
+  try {
+    deleteFile(filePath);
+    revalidatePath('/', 'layout');
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to delete file' };
+  }
+}
+
+export async function renameFileAction(oldPath: string, newName: string): Promise<{ success: boolean; newPath?: string; error?: string }> {
+  try {
+    const newPath = renameFile(oldPath, newName);
+    revalidatePath('/', 'layout');
+    return { success: true, newPath };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to rename file' };
+  }
+}

package/app/lib/agent/index.ts

@@ -0,0 +1,3 @@
+export { getModel } from './model';
+export { knowledgeBaseTools, truncate, assertWritable } from './tools';
+export { AGENT_SYSTEM_PROMPT } from './prompt';

package/app/lib/agent/model.ts

@@ -0,0 +1,18 @@
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createOpenAI } from '@ai-sdk/openai';
+import { effectiveAiConfig } from '@/lib/settings';
+
+export function getModel() {
+  const cfg = effectiveAiConfig();
+
+  if (cfg.provider === 'openai') {
+    const openai = createOpenAI({
+      apiKey: cfg.openaiApiKey,
+      baseURL: cfg.openaiBaseUrl || undefined,
+    });
+    return openai.chat(cfg.openaiModel);
+  }
+
+  const anthropic = createAnthropic({ apiKey: cfg.anthropicApiKey });
+  return anthropic(cfg.anthropicModel);
+}