@geminilight/mindos 0.6.29 → 0.6.31

package/app/lib/core/trash.ts

@@ -0,0 +1,241 @@
+import fs from 'fs';
+import path from 'path';
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface TrashMeta {
+  id: string;
+  originalPath: string;
+  deletedAt: string;
+  expiresAt: string;
+  fileName: string;
+  isDirectory: boolean;
+}
+
+const TRASH_DIR = '.trash';
+const META_DIR = '.trash-meta';
+const EXPIRY_DAYS = 30;
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function siblingDir(mindRoot: string, name: string): string {
+  return path.join(path.dirname(mindRoot), name);
+}
+
+function trashRoot(mindRoot: string): string {
+  return siblingDir(mindRoot, TRASH_DIR);
+}
+
+function metaRoot(mindRoot: string): string {
+  return siblingDir(mindRoot, META_DIR);
+}
+
+function ensureDirs(mindRoot: string): void {
+  fs.mkdirSync(trashRoot(mindRoot), { recursive: true });
+  fs.mkdirSync(metaRoot(mindRoot), { recursive: true });
+}
+
+/** Sanitize filename for use as trash ID — strip all unsafe characters */
+function generateId(fileName: string): string {
+  const safe = fileName.replace(/[^a-zA-Z0-9._\-\u4e00-\u9fff]/g, '_');
+  return `${Date.now()}_${safe}`;
+}
+
+function writeMeta(mindRoot: string, meta: TrashMeta): void {
+  const metaPath = path.join(metaRoot(mindRoot), `${meta.id}.json`);
+  fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2), 'utf-8');
+}
+
+function readMeta(mindRoot: string, id: string): TrashMeta | null {
+  const metaPath = path.join(metaRoot(mindRoot), `${id}.json`);
+  if (!fs.existsSync(metaPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function deleteMeta(mindRoot: string, id: string): void {
+  const metaPath = path.join(metaRoot(mindRoot), `${id}.json`);
+  try { fs.unlinkSync(metaPath); } catch { /* already gone */ }
+}
+
+/**
+ * Move a file or directory safely, handling cross-filesystem (EXDEV) errors.
+ * Tries atomic rename first, falls back to copy+delete.
+ */
+function safeMove(src: string, dest: string, isDir: boolean): void {
+  if (isDir) {
+    // Directories always use copy+delete (rename doesn't work for dirs across fs)
+    fs.cpSync(src, dest, { recursive: true });
+    fs.rmSync(src, { recursive: true, force: true });
+  } else {
+    try {
+      fs.renameSync(src, dest);
+    } catch (err: unknown) {
+      const e = err as NodeJS.ErrnoException;
+      if (e.code === 'EXDEV') {
+        // Cross-device: fallback to copy+delete
+        fs.copyFileSync(src, dest);
+        fs.unlinkSync(src);
+      } else {
+        throw err;
+      }
+    }
+  }
+}
+
+// ─── Core Operations ─────────────────────────────────────────────────────────
+
+export function moveToTrash(mindRoot: string, filePath: string): TrashMeta {
+  ensureDirs(mindRoot);
+  const src = path.join(mindRoot, filePath);
+  if (!fs.existsSync(src)) throw new Error(`File not found: ${filePath}`);
+
+  const isDir = fs.statSync(src).isDirectory();
+  const fileName = path.basename(filePath);
+  const id = generateId(fileName);
+  const dest = path.join(trashRoot(mindRoot), id);
+
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  safeMove(src, dest, isDir);
+
+  const now = new Date();
+  const meta: TrashMeta = {
+    id,
+    originalPath: filePath,
+    deletedAt: now.toISOString(),
+    expiresAt: new Date(now.getTime() + EXPIRY_DAYS * 86400000).toISOString(),
+    fileName,
+    isDirectory: isDir,
+  };
+  writeMeta(mindRoot, meta);
+  return meta;
+}
+
+export function restoreFromTrash(mindRoot: string, trashId: string, overwrite = false): { restoredPath: string } {
+  const meta = readMeta(mindRoot, trashId);
+  if (!meta) throw new Error('Item not found in trash');
+
+  const trashPath = path.join(trashRoot(mindRoot), trashId);
+  if (!fs.existsSync(trashPath)) throw new Error('Trash file missing from disk');
+
+  const dest = path.join(mindRoot, meta.originalPath);
+
+  // Check for conflicts
+  if (fs.existsSync(dest) && !overwrite) {
+    throw Object.assign(new Error('Restore conflict: file exists at original location'), { code: 'RESTORE_CONFLICT' });
+  }
+
+  // Ensure parent directory exists
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+
+  if (meta.isDirectory) {
+    if (overwrite && fs.existsSync(dest)) {
+      fs.rmSync(dest, { recursive: true, force: true });
+    }
+  } else {
+    if (overwrite && fs.existsSync(dest)) {
+      fs.unlinkSync(dest);
+    }
+  }
+
+  safeMove(trashPath, dest, meta.isDirectory);
+  deleteMeta(mindRoot, trashId);
+  return { restoredPath: meta.originalPath };
+}
+
+export function restoreAsCopy(mindRoot: string, trashId: string): { restoredPath: string } {
+  const meta = readMeta(mindRoot, trashId);
+  if (!meta) throw new Error('Item not found in trash');
+
+  const trashPath = path.join(trashRoot(mindRoot), trashId);
+  if (!fs.existsSync(trashPath)) throw new Error('Trash file missing from disk');
+
+  // Generate a unique copy name
+  const dir = path.dirname(meta.originalPath);
+  const ext = path.extname(meta.fileName);
+  const base = path.basename(meta.fileName, ext);
+  let copyPath = path.join(dir, `${base} (copy)${ext}`);
+  let counter = 2;
+  while (fs.existsSync(path.join(mindRoot, copyPath))) {
+    copyPath = path.join(dir, `${base} (copy ${counter})${ext}`);
+    counter++;
+  }
+
+  const dest = path.join(mindRoot, copyPath);
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  safeMove(trashPath, dest, meta.isDirectory);
+
+  deleteMeta(mindRoot, trashId);
+  return { restoredPath: copyPath };
+}
+
+export function permanentlyDelete(mindRoot: string, trashId: string): void {
+  const trashPath = path.join(trashRoot(mindRoot), trashId);
+  try {
+    if (fs.existsSync(trashPath)) {
+      const stat = fs.statSync(trashPath);
+      if (stat.isDirectory()) {
+        fs.rmSync(trashPath, { recursive: true, force: true });
+      } else {
+        fs.unlinkSync(trashPath);
+      }
+    }
+  } catch { /* file already gone */ }
+  deleteMeta(mindRoot, trashId);
+}
+
+export function listTrash(mindRoot: string): TrashMeta[] {
+  ensureDirs(mindRoot);
+  const metaDir = metaRoot(mindRoot);
+  let files: string[];
+  try {
+    files = fs.readdirSync(metaDir).filter(f => f.endsWith('.json'));
+  } catch {
+    return [];
+  }
+  const items: TrashMeta[] = [];
+
+  for (const file of files) {
+    try {
+      const meta = JSON.parse(fs.readFileSync(path.join(metaDir, file), 'utf-8')) as TrashMeta;
+      // Verify the trash file still exists on disk
+      const trashPath = path.join(trashRoot(mindRoot), meta.id);
+      if (fs.existsSync(trashPath)) {
+        items.push(meta);
+      } else {
+        // Clean up orphaned metadata
+        try { fs.unlinkSync(path.join(metaDir, file)); } catch { /* race ok */ }
+      }
+    } catch {
+      // Skip corrupt metadata files
+    }
+  }
+
+  // Sort by deletion time, newest first
+  items.sort((a, b) => new Date(b.deletedAt).getTime() - new Date(a.deletedAt).getTime());
+  return items;
+}
+
+export function emptyTrash(mindRoot: string): number {
+  const items = listTrash(mindRoot);
+  for (const item of items) {
+    permanentlyDelete(mindRoot, item.id);
+  }
+  return items.length;
+}
+
+export function purgeExpired(mindRoot: string): number {
+  const items = listTrash(mindRoot);
+  const now = Date.now();
+  let count = 0;
+  for (const item of items) {
+    if (new Date(item.expiresAt).getTime() <= now) {
+      permanentlyDelete(mindRoot, item.id);
+      count++;
+    }
+  }
+  return count;
+}

package/app/lib/fs.ts

@@ -601,6 +601,53 @@ export type { BacklinkEntry } from './core/types';
 export type { MindSpaceSummary } from './core';
 export type { ContentChangeEvent, ContentChangeInput, ContentChangeSummary, ContentChangeSource } from './core';
 
+// ─── Public API: Trash (delegated to @mindos/core/trash) ────────────────────
+
+import {
+  moveToTrash as coreMoveToTrash,
+  restoreFromTrash as coreRestoreFromTrash,
+  restoreAsCopy as coreRestoreAsCopy,
+  permanentlyDelete as corePermanentlyDelete,
+  listTrash as coreListTrash,
+  emptyTrash as coreEmptyTrash,
+  purgeExpired as corePurgeExpired,
+} from './core/trash';
+export type { TrashMeta } from './core/trash';
+
+export function moveToTrashFile(filePath: string) {
+  const result = coreMoveToTrash(getMindRoot(), filePath);
+  invalidateCache();
+  return result;
+}
+
+export function restoreFromTrash(trashId: string, overwrite = false) {
+  const result = coreRestoreFromTrash(getMindRoot(), trashId, overwrite);
+  invalidateCache();
+  return result;
+}
+
+export function restoreAsCopy(trashId: string) {
+  const result = coreRestoreAsCopy(getMindRoot(), trashId);
+  invalidateCache();
+  return result;
+}
+
+export function permanentlyDeleteFromTrash(trashId: string) {
+  corePermanentlyDelete(getMindRoot(), trashId);
+}
+
+export function listTrash() {
+  return coreListTrash(getMindRoot());
+}
+
+export function emptyTrashAll() {
+  return coreEmptyTrash(getMindRoot());
+}
+
+export function purgeExpiredTrash() {
+  return corePurgeExpired(getMindRoot());
+}
+
 export function findBacklinks(targetPath: string): BacklinkEntry[] {
   const { allFiles } = ensureCache();
   return coreFindBacklinks(getMindRoot(), targetPath, allFiles);

package/app/lib/hooks/usePinnedFiles.ts

@@ -0,0 +1,90 @@
+'use client';
+
+import { useSyncExternalStore, useCallback } from 'react';
+
+const STORAGE_KEY = 'mindos-pinned-files';
+const EVENT_KEY = 'mindos:pins-changed';
+
+function getSnapshot(): string[] {
+  if (typeof window === 'undefined') return [];
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    return raw ? JSON.parse(raw) : [];
+  } catch {
+    return [];
+  }
+}
+
+function getServerSnapshot(): string[] {
+  return [];
+}
+
+// Lazy init — avoid calling getSnapshot() at module load time during SSR
+let cachedPins: string[] = [];
+let initialized = false;
+
+function ensureInit(): void {
+  if (!initialized && typeof window !== 'undefined') {
+    cachedPins = getSnapshot();
+    initialized = true;
+  }
+}
+
+function subscribe(callback: () => void): () => void {
+  ensureInit();
+  const onStorage = (e: StorageEvent) => {
+    if (e.key === STORAGE_KEY) {
+      cachedPins = getSnapshot();
+      callback();
+    }
+  };
+  const onCustom = () => {
+    cachedPins = getSnapshot();
+    callback();
+  };
+  window.addEventListener('storage', onStorage);
+  window.addEventListener(EVENT_KEY, onCustom);
+  return () => {
+    window.removeEventListener('storage', onStorage);
+    window.removeEventListener(EVENT_KEY, onCustom);
+  };
+}
+
+function writePins(pins: string[]): void {
+  cachedPins = pins;
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(pins));
+  } catch {
+    // localStorage unavailable (private browsing, quota exceeded) — memory only
+  }
+  window.dispatchEvent(new Event(EVENT_KEY));
+}
+
+export function usePinnedFiles() {
+  ensureInit();
+  const pins = useSyncExternalStore(subscribe, () => cachedPins, getServerSnapshot);
+
+  const isPinned = useCallback((path: string) => pins.includes(path), [pins]);
+
+  const togglePin = useCallback((path: string) => {
+    const current = getSnapshot();
+    const idx = current.indexOf(path);
+    if (idx >= 0) {
+      current.splice(idx, 1);
+    } else {
+      current.unshift(path); // newest pin at top
+    }
+    writePins(current);
+  }, []);
+
+  const reorderPins = useCallback((newOrder: string[]) => {
+    writePins(newOrder);
+  }, []);
+
+  const removePin = useCallback((path: string) => {
+    const current = getSnapshot();
+    writePins(current.filter(p => p !== path));
+  }, []);
+
+  return { pinnedFiles: pins, isPinned, togglePin, reorderPins, removePin };
+}

package/app/lib/i18n/generated/explore-i18n.generated.ts

@@ -0,0 +1,138 @@
+// ⚠️ AUTO-GENERATED — DO NOT EDIT. Source: components/explore/use-cases.yaml
+// Run `npm run generate` to regenerate.
+
+export const exploreEn = {
+  "title": "Explore Use Cases",
+  "subtitle": "Discover what you can do with MindOS — pick a scenario and try it now.",
+  "tryIt": "Try it",
+  "all": "All",
+  "byCapability": "By Capability",
+  "byScenario": "By Scenario",
+  "categories": {
+    "knowledge-management": "Knowledge Management",
+    "memory-sync": "Memory Sync",
+    "auto-execute": "Auto Execute",
+    "experience-evolution": "Experience Evolution",
+    "human-insights": "Human Insights",
+    "audit-control": "Audit & Control"
+  },
+  "scenarios": {
+    "first-day": "First Day",
+    "daily": "Daily Work",
+    "project": "Project Work",
+    "advanced": "Advanced"
+  },
+  "c1": {
+    "title": "Inject Your Identity",
+    "desc": "Tell all AI agents who you are — preferences, tech stack, communication style — in one shot.",
+    "prompt": "Here's my resume, read it and organize my info into MindOS."
+  },
+  "c2": {
+    "title": "Save Information",
+    "desc": "Archive articles, meeting notes, or web pages into your knowledge base with one prompt.",
+    "prompt": "Help me save the key points from this article into MindOS."
+  },
+  "c3": {
+    "title": "Cross-Agent Handoff",
+    "desc": "Start a plan in MindOS, continue coding in Claude Code, refine in Cursor — zero context loss.",
+    "prompt": "Help me start coding based on the plan in MindOS."
+  },
+  "c4": {
+    "title": "Experience → SOP",
+    "desc": "Turn hard-won debugging sessions into reusable workflows that prevent future mistakes.",
+    "prompt": "Help me distill this conversation into a reusable workflow in MindOS."
+  },
+  "c5": {
+    "title": "Capture Ideas on the Go",
+    "desc": "Jot down an inspiration on your phone — MindOS archives, decomposes, and assigns to agents.",
+    "prompt": "Help me organize this idea into MindOS and break it into actionable sub-tasks."
+  },
+  "c6": {
+    "title": "Project Cold Start",
+    "desc": "Spin up a new project in 4 minutes — your profile and SOPs guide the scaffolding automatically.",
+    "prompt": "Help me start a new project following the Startup SOP in MindOS."
+  },
+  "c7": {
+    "title": "Research & Archive",
+    "desc": "Let agents research competitors or topics for you, then file structured results in your KB.",
+    "prompt": "Help me research X, Y, Z products and save results to the MindOS product library."
+  },
+  "c8": {
+    "title": "Network Management",
+    "desc": "Log conversations with contacts, auto-generate follow-up TODOs, and keep full context.",
+    "prompt": "I met with someone today — update MindOS Connections and create follow-up TODOs."
+  },
+  "c9": {
+    "title": "Audit & Correct",
+    "desc": "Review what agents know about you, fix mistakes in one place, and all agents update instantly.",
+    "prompt": "Check my MindOS Profile for accuracy and correct any errors."
+  }
+} as const;
+
+export const exploreZh = {
+  "title": "探索使用场景",
+  "subtitle": "发现 MindOS 能帮你做什么 — 选一个场景，立即体验。",
+  "tryIt": "试一试",
+  "all": "全部",
+  "byCapability": "按能力",
+  "byScenario": "按场景",
+  "categories": {
+    "knowledge-management": "知识管理",
+    "memory-sync": "记忆同步",
+    "auto-execute": "自动执行",
+    "experience-evolution": "经验进化",
+    "human-insights": "人类洞察",
+    "audit-control": "审计纠错"
+  },
+  "scenarios": {
+    "first-day": "初次使用",
+    "daily": "日常工作",
+    "project": "项目协作",
+    "advanced": "高级"
+  },
+  "c1": {
+    "title": "注入身份",
+    "desc": "让所有 AI Agent 一次认识你 — 偏好、技术栈、沟通风格。",
+    "prompt": "这是我的简历，读一下，把我的信息整理到 MindOS 里。"
+  },
+  "c2": {
+    "title": "注入信息",
+    "desc": "一句话归档文章、会议纪要或网页到知识库，全局可搜。",
+    "prompt": "帮我把这篇文章的要点整理到 MindOS 里。"
+  },
+  "c3": {
+    "title": "跨 Agent 切换",
+    "desc": "在 MindOS 写方案，在 Claude Code 写代码，在 Cursor 优化 — 零重复。",
+    "prompt": "帮我按 MindOS 里的 XXX 方案开始写代码。"
+  },
+  "c4": {
+    "title": "经验→SOP",
+    "desc": "把踩坑经验沉淀为可复用的工作流，下次 3 分钟搞定。",
+    "prompt": "帮我把这次对话的经验沉淀到 MindOS，形成可复用的工作流。"
+  },
+  "c5": {
+    "title": "手机记灵感",
+    "desc": "随手记下灵感，MindOS 自动归档、拆任务、多 Agent 接力执行。",
+    "prompt": "帮我把这个想法整理到 MindOS，拆解成可执行的子任务。"
+  },
+  "c6": {
+    "title": "项目冷启动",
+    "desc": "4 分钟搭建新项目 — Profile 和 SOP 自动引导脚手架。",
+    "prompt": "帮我按 MindOS 里的 Startup SOP 启动一个新项目。"
+  },
+  "c7": {
+    "title": "调研入库",
+    "desc": "让 Agent 替你跑腿调研竞品或话题，结果结构化入库。",
+    "prompt": "帮我调研 X、Y、Z 这几个产品，结果写入 MindOS 产品库。"
+  },
+  "c8": {
+    "title": "人脉管理",
+    "desc": "记录对话、自动生成跟进待办，每个联系人都有完整上下文。",
+    "prompt": "我今天和 XXX 聊了这些内容，帮我更新到 MindOS 并生成跟进待办。"
+  },
+  "c9": {
+    "title": "审计纠偏",
+    "desc": "审查 Agent 记了什么，一处修正，全局生效。",
+    "prompt": "帮我检查 MindOS Profile 里的技术栈偏好是否正确，有错误帮我修正。"
+  }
+} as const;

package/app/lib/i18n/index.ts

@@ -7,6 +7,7 @@ import { panelsEn, panelsZh } from './modules/panels';
 import { settingsEn, settingsZh } from './modules/settings';
 import { onboardingEn, onboardingZh } from './modules/onboarding';
 import { featuresEn, featuresZh } from './modules/features';
+import { exploreEn, exploreZh } from './generated/explore-i18n.generated';
 
 export const en = {
   ...commonEn,
@@ -17,6 +18,7 @@ export const en = {
   ...settingsEn,
   ...onboardingEn,
   ...featuresEn,
+  explore: exploreEn,
 } as const;
 
 export const zh: Widen<typeof en> = {
@@ -28,6 +30,7 @@ export const zh: Widen<typeof en> = {
   ...settingsZh,
   ...onboardingZh,
   ...featuresZh,
+  explore: exploreZh,
 };
 
 export type Locale = 'en' | 'zh';