@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/lib/daily-echo/types.ts

@@ -0,0 +1,340 @@
+/**
+ * Daily Echo (每日回响) — Type Definitions
+ *
+ * Complete TypeScript interfaces and types for the Daily Echo feature.
+ * Type-first design: All data structures defined before implementation.
+ */
+
+/**
+ * Daily Echo Configuration
+ * Stored in localStorage under key: 'mindos-daily-echo-config'
+ */
+export interface DailyEchoConfig {
+  /** Enable/disable daily echo reports */
+  enabled: boolean;
+
+  /** Scheduled generation time (24-hour format, e.g., "20:00") */
+  scheduleTime: string;
+
+  /** Timezone identifier (e.g., "Asia/Shanghai") */
+  timezone: string;
+
+  /** Report language */
+  language: 'en' | 'zh';
+
+  /** Include chat sessions in analysis */
+  includeChat: boolean;
+
+  /** Include 7-day trend analysis (when available) */
+  includeTrendAnalysis: boolean;
+
+  /** Target report length */
+  maxReportLength: 'short' | 'medium' | 'long';
+}
+
+/**
+ * Default Daily Echo config
+ */
+export const DEFAULT_DAILY_ECHO_CONFIG: DailyEchoConfig = {
+  enabled: false,
+  scheduleTime: '20:00',
+  timezone: 'Asia/Shanghai',
+  language: 'zh',
+  includeChat: true,
+  includeTrendAnalysis: true,
+  maxReportLength: 'medium',
+};
+
+/**
+ * Raw aggregated data from 24-hour window
+ * Intermediate result from data aggregation layer
+ */
+export interface DailyEchoRawData {
+  /** Date in YYYY-MM-DD format */
+  date: string;
+
+  /** Array of file paths edited (for theme extraction) */
+  fileNames: string[];
+
+  /** Number of files created in 24-hour window */
+  filesCreated: number;
+
+  /** Total number of distinct files edited */
+  filesEdited: number;
+
+  /** Number of chat sessions */
+  sessionCount: number;
+
+  /** KB growth displayed as "+12 KB" or "same" */
+  kbGrowth: string;
+
+  /** User's stated daily intention */
+  dailyLine: string;
+
+  /** User's stated long-term growth direction */
+  growthIntent: string;
+}
+
+/**
+ * Quick summary statistics shown in report header
+ */
+export interface DailySnapshot {
+  /** Number of distinct files edited */
+  filesEdited: number;
+
+  /** Number of newly created files */
+  filesCreated: number;
+
+  /** Number of AI chat sessions */
+  sessionCount: number;
+
+  /** Knowledge base growth (e.g., "+12 KB") */
+  kbGrowth: string;
+}
+
+/**
+ * Identified theme/project from user's daily work
+ * Result of theme extraction LLM call
+ */
+export interface DailyTheme {
+  /** Human-readable theme name (e.g., "Infrastructure & DevOps") */
+  name: string;
+
+  /** Number of files related to this theme */
+  fileCount: number;
+
+  /** Percentage of total activity (0-100) */
+  percentage: number;
+
+  /** Brief description of this theme's work */
+  description: string;
+
+  /** Classification of work type */
+  workType: 'strategic' | 'tactical' | 'learning' | 'maintenance';
+}
+
+/**
+ * Alignment analysis between stated intent and actual work
+ * Result of alignment analysis LLM call
+ */
+export interface AlignmentAnalysis {
+  /** Alignment score (0-100), where:
+   * 0-40: Misaligned (red)
+   * 40-70: Partially aligned (amber)
+   * 70-100: Well aligned (green)
+   */
+  alignmentScore: number;
+
+  /** Markdown narrative analyzing the alignment */
+  analysis: string;
+
+  /** Why was there alignment/misalignment? */
+  reasoning?: string;
+}
+
+/**
+ * Reflection prompts to guide user's thinking
+ * Result of reflection generation LLM call
+ */
+export interface ReflectionPrompts {
+  /** Array of 2-3 thoughtful questions */
+  prompts: string[];
+}
+
+/**
+ * Growth vector analysis (7-day trends if available)
+ * Optional: only included if includeTrendAnalysis enabled and enough history
+ */
+export interface GrowthVector {
+  /** Is user deepening (revisiting) or expanding (new areas)? */
+  trend: 'deepening' | 'expanding' | 'balanced';
+
+  /** Velocity metric (e.g., "12 files/week") */
+  velocity: string;
+
+  /** Session frequency trend (increasing/steady/decreasing) */
+  sessionTrend: 'increasing' | 'steady' | 'decreasing';
+
+  /** Specialization analysis (concentrating or broadening?) */
+  specialization: string;
+
+  /** Plain English implication of the trends */
+  implication: string;
+}
+
+/**
+ * Complete Daily Echo Report
+ * Stored in IndexedDB under key: 'YYYY-MM-DD'
+ */
+export interface DailyEchoReport {
+  /** Unique identifier (UUID) */
+  id: string;
+
+  /** ISO 8601 timestamp when report was generated */
+  generatedAt: string;
+
+  /** Date in YYYY-MM-DD format (used as IndexedDB key) */
+  date: string;
+
+  /** Quick statistics snapshot */
+  snapshot: DailySnapshot;
+
+  /** Identified themes/projects from the day (2-4 items) */
+  themes: DailyTheme[];
+
+  /** Alignment analysis */
+  alignment: AlignmentAnalysis;
+
+  /** Reflection prompts for user */
+  reflectionPrompts: ReflectionPrompts;
+
+  /** Optional: Growth trends if available */
+  growthVector?: GrowthVector;
+
+  /** Full markdown version (for export) */
+  rawMarkdown: string;
+}
+
+/**
+ * API Request: Generate Daily Echo Report
+ * POST /api/daily-echo/generate
+ */
+export interface DailyEchoGenerateRequest {
+  /** Date to generate report for (defaults to today) */
+  date?: string;
+
+  /** Optional force regenerate even if cached */
+  force?: boolean;
+}
+
+/**
+ * API Response: Daily Echo Report generated/retrieved
+ * 200 OK response from /api/daily-echo/generate
+ */
+export interface DailyEchoGenerateResponse {
+  /** The generated or cached report */
+  report: DailyEchoReport;
+
+  /** Whether this was a cached result vs. newly generated */
+  cached: boolean;
+
+  /** When the report was generated */
+  generatedAt: string;
+}
+
+/**
+ * API Error Response
+ */
+export interface DailyEchoErrorResponse {
+  /** Machine-readable error code */
+  code:
+    | 'no_knowledge_base'
+    | 'no_ai_provider'
+    | 'generation_failed'
+    | 'invalid_date'
+    | 'storage_error';
+
+  /** Human-readable error message */
+  message: string;
+
+  /** Additional error details (stack trace in dev) */
+  details?: string;
+}
+
+/**
+ * UI State: Report drawer/modal open/close
+ */
+export interface DailyEchoUIState {
+  /** Is the report drawer visible? */
+  isOpen: boolean;
+
+  /** Currently displayed report (null = no report loaded) */
+  report: DailyEchoReport | null;
+
+  /** Is generation in progress? */
+  isGenerating: boolean;
+
+  /** Error state during generation */
+  error: string | null;
+}
+
+/**
+ * Theme extraction LLM prompt request
+ * Internal: used for orchestrating LLM calls
+ */
+export interface ThemeExtractionRequest {
+  fileNames: string[];
+  language: 'en' | 'zh';
+}
+
+/**
+ * Theme extraction LLM response
+ */
+export interface ThemeExtractionResponse {
+  themes: DailyTheme[];
+}
+
+/**
+ * Alignment analysis LLM prompt request
+ */
+export interface AlignmentAnalysisRequest {
+  dailyLine: string;
+  growthIntent: string;
+  themes: DailyTheme[];
+  language: 'en' | 'zh';
+}
+
+/**
+ * Alignment analysis LLM response
+ */
+export interface AlignmentAnalysisResponse {
+  alignmentScore: number;
+  analysis: string;
+  reasoning?: string;
+}
+
+/**
+ * Reflection generation LLM prompt request
+ */
+export interface ReflectionGenerationRequest {
+  alignment: AlignmentAnalysis;
+  themes: DailyTheme[];
+  dailyLine: string;
+  growthIntent: string;
+  language: 'en' | 'zh';
+}
+
+/**
+ * Reflection generation LLM response
+ */
+export interface ReflectionGenerationResponse {
+  prompts: string[];
+}
+
+/**
+ * Content change event from `/api/changes`
+ * Used to track file edits
+ */
+export interface ContentChangeEvent {
+  id: string;
+  path: string;
+  op: 'create' | 'write' | 'delete' | 'rename' | 'move' | 'append';
+  ts: string; // ISO 8601
+}
+
+/**
+ * Chat session from `/api/ask-sessions`
+ * Used to count sessions in 24-hour window
+ */
+export interface ChatSession {
+  id: string;
+  createdAt: string; // ISO 8601
+  updatedAt: string;
+  title?: string;
+  messageCount: number;
+}
+
+/**
+ * Export/download format options
+ */
+export type DailyEchoExportFormat = 'markdown' | 'pdf' | 'json';

package/_standalone/lib/db/daily-echo-db.ts

@@ -0,0 +1,194 @@
+/**
+ * Daily Echo Report Storage (IndexedDB)
+ *
+ * Persist generated reports for offline access and history
+ */
+
+import type { DailyEchoReport } from '../daily-echo/types';
+
+const DB_NAME = 'mindos-daily-echo';
+const DB_VERSION = 1;
+const STORE_NAME = 'reports';
+
+let db: IDBDatabase | null = null;
+
+/**
+ * Initialize IndexedDB
+ */
+async function initDB(): Promise<IDBDatabase> {
+  if (db) {
+    return db;
+  }
+
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+
+    request.onerror = () => {
+      reject(new Error(`Failed to open IndexedDB: ${request.error}`));
+    };
+
+    request.onupgradeneeded = event => {
+      const database = (event.target as IDBOpenDBRequest).result;
+      if (!database.objectStoreNames.contains(STORE_NAME)) {
+        database.createObjectStore(STORE_NAME, { keyPath: 'date' });
+      }
+    };
+
+    request.onsuccess = () => {
+      db = request.result;
+      resolve(db);
+    };
+  });
+}
+
+/**
+ * Save a daily echo report
+ */
+export async function saveDailyEchoReport(
+  report: DailyEchoReport
+): Promise<void> {
+  const database = await initDB();
+  const transaction = database.transaction(STORE_NAME, 'readwrite');
+  const store = transaction.objectStore(STORE_NAME);
+
+  return new Promise((resolve, reject) => {
+    const request = store.put(report);
+
+    request.onerror = () => {
+      reject(
+        new Error(
+          `Failed to save report: ${request.error?.message || 'Unknown error'}`
+        )
+      );
+    };
+
+    request.onsuccess = () => {
+      resolve();
+    };
+  });
+}
+
+/**
+ * Get a report by date
+ */
+export async function getDailyEchoReport(
+  date: string
+): Promise<DailyEchoReport | null> {
+  const database = await initDB();
+  const transaction = database.transaction(STORE_NAME, 'readonly');
+  const store = transaction.objectStore(STORE_NAME);
+
+  return new Promise((resolve, reject) => {
+    const request = store.get(date);
+
+    request.onerror = () => {
+      reject(
+        new Error(
+          `Failed to get report: ${request.error?.message || 'Unknown error'}`
+        )
+      );
+    };
+
+    request.onsuccess = () => {
+      resolve(request.result ?? null);
+    };
+  });
+}
+
+/**
+ * Get all reports
+ */
+export async function getAllDailyEchoReports(): Promise<
+  DailyEchoReport[]
+> {
+  const database = await initDB();
+  const transaction = database.transaction(STORE_NAME, 'readonly');
+  const store = transaction.objectStore(STORE_NAME);
+
+  return new Promise((resolve, reject) => {
+    const request = store.getAll();
+
+    request.onerror = () => {
+      reject(
+        new Error(
+          `Failed to get reports: ${request.error?.message || 'Unknown error'}`
+        )
+      );
+    };
+
+    request.onsuccess = () => {
+      resolve(request.result ?? []);
+    };
+  });
+}
+
+/**
+ * Delete a report by date
+ */
+export async function deleteDailyEchoReport(date: string): Promise<void> {
+  const database = await initDB();
+  const transaction = database.transaction(STORE_NAME, 'readwrite');
+  const store = transaction.objectStore(STORE_NAME);
+
+  return new Promise((resolve, reject) => {
+    const request = store.delete(date);
+
+    request.onerror = () => {
+      reject(
+        new Error(
+          `Failed to delete report: ${request.error?.message || 'Unknown error'}`
+        )
+      );
+    };
+
+    request.onsuccess = () => {
+      resolve();
+    };
+  });
+}
+
+/**
+ * Clean up old reports (keep only last N days)
+ */
+export async function cleanupOldReports(
+  daysToKeep: number = 30
+): Promise<void> {
+  const database = await initDB();
+  const transaction = database.transaction(STORE_NAME, 'readwrite');
+  const store = transaction.objectStore(STORE_NAME);
+
+  const cutoff = Date.now() - daysToKeep * 86400000; // milliseconds
+
+  return new Promise((resolve, reject) => {
+    const getAllRequest = store.getAll();
+
+    getAllRequest.onerror = () => {
+      reject(
+        new Error(
+          `Failed to cleanup reports: ${getAllRequest.error?.message || 'Unknown error'}`
+        )
+      );
+    };
+
+    getAllRequest.onsuccess = () => {
+      const reports = getAllRequest.result ?? [];
+      const toDelete: string[] = [];
+
+      for (const report of reports) {
+        const reportTime = new Date(report.generatedAt).getTime();
+        if (reportTime < cutoff) {
+          toDelete.push(report.date);
+        }
+      }
+
+      for (const date of toDelete) {
+        const deleteRequest = store.delete(date);
+        deleteRequest.onerror = () => {
+          console.warn(`Failed to delete old report: ${date}`);
+        };
+      }
+
+      resolve();
+    };
+  });
+}

package/_standalone/lib/echo-insight-prompt.ts

@@ -0,0 +1,38 @@
+import type { EchoSegment } from '@/lib/echo-segments';
+
+export function buildEchoInsightUserPrompt(opts: {
+  locale: 'en' | 'zh';
+  segment: EchoSegment;
+  segmentTitle: string;
+  factsHeading: string;
+  emptyTitle: string;
+  emptyBody: string;
+  dailyLineLabel: string;
+  dailyLine: string;
+  growthIntentLabel: string;
+  growthIntent: string;
+}): string {
+  const lang = opts.locale === 'zh' ? 'Chinese' : 'English';
+  const lines: string[] = [
+    `Echo section: ${opts.segmentTitle}`,
+    `${opts.factsHeading}: ${opts.emptyTitle}`,
+    opts.emptyBody,
+  ];
+
+  if (opts.segment === 'imprint' && opts.dailyLine.trim()) {
+    lines.push(`${opts.dailyLineLabel}: ${opts.dailyLine.trim()}`);
+  }
+  if (opts.segment === 'growth' && opts.growthIntent.trim()) {
+    lines.push(`${opts.growthIntentLabel}: ${opts.growthIntent.trim()}`);
+  }
+
+  const context = lines.join('\n\n');
+
+  return `You are a reflective assistant inside MindOS Echo (a personal, local-first notes companion). The user is viewing one Echo section. Below is exactly what they see on screen right now—it may be an empty-state placeholder until indexing fills the list.
+
+--- Visible context ---
+${context}
+---
+
+Write a short insight in ${lang} as Markdown (under 220 words). Tone: warm, restrained, "quiet notebook"—not a hype coach. If the context is only generic empty copy, acknowledge that briefly and offer 2–3 reflection prompts instead of inventing files or facts. Do not claim you read their whole library. Prefer answering from this context; avoid unnecessary tool use.`;
+}

package/_standalone/lib/hooks/useDirectoryDragDrop.ts

@@ -0,0 +1,94 @@
+'use client';
+
+import { useState, useCallback, useRef, useEffect } from 'react';
+import type { FileNode } from '@/lib/types';
+import { quickDropToDirectory } from '@/lib/inbox-upload';
+
+/**
+ * Encapsulates drag-and-drop logic for directory nodes in the file tree.
+ * Handles highlight, auto-expand on hover, and file drop.
+ */
+export function useDirectoryDragDrop(
+  node: FileNode,
+  open: boolean,
+  setOpen: (v: boolean) => void,
+  t: Record<string, unknown>,
+) {
+  const [isDragTarget, setIsDragTarget] = useState(false);
+  const autoExpandTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const dragLeaveTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const clearAutoExpand = useCallback(() => {
+    if (autoExpandTimerRef.current) {
+      clearTimeout(autoExpandTimerRef.current);
+      autoExpandTimerRef.current = null;
+    }
+  }, []);
+
+  const handleRowDragOver = useCallback((e: React.DragEvent) => {
+    if (!e.dataTransfer.types.includes('Files')) return;
+    e.preventDefault();
+    e.stopPropagation();
+    e.dataTransfer.dropEffect = 'copy';
+    if (dragLeaveTimerRef.current) {
+      clearTimeout(dragLeaveTimerRef.current);
+      dragLeaveTimerRef.current = null;
+    }
+    if (!isDragTarget) setIsDragTarget(true);
+  }, [isDragTarget]);
+
+  const handleRowDragEnter = useCallback((e: React.DragEvent) => {
+    if (!e.dataTransfer.types.includes('Files')) return;
+    e.preventDefault();
+    e.stopPropagation();
+    setIsDragTarget(true);
+    clearAutoExpand();
+    if (!open) {
+      autoExpandTimerRef.current = setTimeout(() => {
+        setOpen(true);
+        autoExpandTimerRef.current = null;
+      }, 500);
+    }
+  }, [open, clearAutoExpand, setOpen]);
+
+  const handleRowDragLeave = useCallback((e: React.DragEvent) => {
+    if (!e.dataTransfer.types.includes('Files')) return;
+    e.stopPropagation();
+    dragLeaveTimerRef.current = setTimeout(() => {
+      setIsDragTarget(false);
+      clearAutoExpand();
+      dragLeaveTimerRef.current = null;
+    }, 50);
+  }, [clearAutoExpand]);
+
+  const handleRowDrop = useCallback((e: React.DragEvent) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsDragTarget(false);
+    clearAutoExpand();
+    if (dragLeaveTimerRef.current) {
+      clearTimeout(dragLeaveTimerRef.current);
+      dragLeaveTimerRef.current = null;
+    }
+    const files = e.dataTransfer.files;
+    if (files.length > 0) {
+      void quickDropToDirectory(Array.from(files), node.path, t as Parameters<typeof quickDropToDirectory>[2]);
+    }
+  }, [node.path, t, clearAutoExpand]);
+
+  // Cleanup timers on unmount
+  useEffect(() => {
+    return () => {
+      if (autoExpandTimerRef.current) clearTimeout(autoExpandTimerRef.current);
+      if (dragLeaveTimerRef.current) clearTimeout(dragLeaveTimerRef.current);
+    };
+  }, []);
+
+  return {
+    isDragTarget,
+    handleRowDragOver,
+    handleRowDragEnter,
+    handleRowDragLeave,
+    handleRowDrop,
+  };
+}