@geminilight/mindos 0.6.39 → 0.6.41

package/app/lib/settings.ts

@@ -2,21 +2,19 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { parseAcpAgentOverrides } from './acp/agent-descriptors';
+import { type ProviderId, PROVIDER_PRESETS, isProviderId, getApiKeyFromEnv } from './agent/providers';
 
 const SETTINGS_PATH = path.join(os.homedir(), '.mindos', 'config.json');
 
 export interface ProviderConfig {
   apiKey: string;
   model: string;
-  baseUrl?: string; // only for openai-compatible providers
+  baseUrl?: string;
 }
 
 export interface AiConfig {
-  provider: 'anthropic' | 'openai';
-  providers: {
-    anthropic: ProviderConfig;
-    openai: ProviderConfig;
-  };
+  provider: ProviderId;
+  providers: Partial<Record<ProviderId, ProviderConfig>>;
 }
 
 export interface AgentConfig {
@@ -57,7 +55,7 @@ export interface ServerSettings {
 
 const DEFAULTS: ServerSettings = {
   ai: {
-    provider: 'anthropic',
+    provider: 'anthropic' as ProviderId,
     providers: {
       anthropic: { apiKey: '', model: 'claude-sonnet-4-6' },
       openai:    { apiKey: '', model: 'gpt-5.4', baseUrl: '' },
@@ -91,20 +89,23 @@ function migrateAi(parsed: Record<string, unknown>): AiConfig {
   const ai = parsed.ai as Record<string, unknown> | undefined;
   if (!ai) return { ...DEFAULTS.ai };
 
-  const providerField = ai.provider;
-  const provider: 'anthropic' | 'openai' =
-    providerField === 'anthropic' || providerField === 'openai' ? providerField : 'anthropic';
+  const providerField = typeof ai.provider === 'string' ? ai.provider : 'anthropic';
+  const provider: ProviderId = isProviderId(providerField) ? providerField : 'anthropic';
 
-  // Already new format
+  // Already new format — parse all known providers from disk
   if (ai.providers && typeof ai.providers === 'object') {
     const p = ai.providers as Record<string, unknown>;
-    return {
-      provider,
-      providers: {
-        anthropic: parseProvider(p.anthropic, DEFAULTS.ai.providers.anthropic),
-        openai:    parseProvider(p.openai,    DEFAULTS.ai.providers.openai),
-      },
-    };
+    const providers: Partial<Record<ProviderId, ProviderConfig>> = {};
+    for (const id of Object.keys(p)) {
+      if (!isProviderId(id)) continue;
+      const preset = PROVIDER_PRESETS[id];
+      const defaultCfg = DEFAULTS.ai.providers[id] ?? { apiKey: '', model: preset.defaultModel };
+      providers[id] = parseProvider(p[id], defaultCfg);
+    }
+    // Ensure at least anthropic and openai exist (backward compat)
+    if (!providers.anthropic) providers.anthropic = DEFAULTS.ai.providers.anthropic;
+    if (!providers.openai) providers.openai = DEFAULTS.ai.providers.openai;
+    return { provider, providers };
   }
 
   // Old flat format — migrate
@@ -169,7 +170,7 @@ export function readSettings(): ServerSettings {
       ai: migrateAi(parsed),
       agent: parseAgent(parsed.agent),
       acpAgents: parseAcpAgentsField(parsed.acpAgents),
-      mindRoot: (parsed.mindRoot ?? parsed.sopRoot ?? DEFAULTS.mindRoot) as string,
+      mindRoot: (parsed.mindRoot ?? DEFAULTS.mindRoot) as string,
       webPassword: typeof parsed.webPassword === 'string' ? parsed.webPassword : undefined,
       authToken:   typeof parsed.authToken   === 'string' ? parsed.authToken   : undefined,
       mcpPort:     typeof parsed.mcpPort     === 'number' ? parsed.mcpPort     : undefined,
@@ -213,21 +214,35 @@ export function writeSettings(settings: ServerSettings): void {
   fs.writeFileSync(SETTINGS_PATH, JSON.stringify(merged, null, 2) + '\n', 'utf-8');
 }
 
-/** Effective AI config — settings file overrides env vars when non-empty */
-export function effectiveAiConfig() {
+/** Effective AI config — unified interface for all providers.
+ *  Resolves: saved config → env var → preset default, in that priority order.
+ *  When `providerOverride` is given, resolves that provider's config instead. */
+export function effectiveAiConfig(providerOverride?: ProviderId): {
+  provider: ProviderId;
+  apiKey: string;
+  model: string;
+  baseUrl: string;
+} {
   const s = readSettings();
-  const provider = (s.ai.provider || process.env.AI_PROVIDER || 'anthropic') as 'anthropic' | 'openai';
-  const anthropic = s.ai.providers.anthropic;
-  const openai    = s.ai.providers.openai;
-
-  return {
-    provider,
-    anthropicApiKey: anthropic.apiKey || process.env.ANTHROPIC_API_KEY || '',
-    anthropicModel:  anthropic.model  || process.env.ANTHROPIC_MODEL   || 'claude-sonnet-4-6',
-    openaiApiKey:    openai.apiKey    || process.env.OPENAI_API_KEY    || '',
-    openaiModel:     openai.model     || process.env.OPENAI_MODEL      || 'gpt-5.4',
-    openaiBaseUrl:   openai.baseUrl   || process.env.OPENAI_BASE_URL   || '',
-  };
+  const envProvider = process.env.AI_PROVIDER;
+  const provider: ProviderId = providerOverride
+    ?? (isProviderId(s.ai.provider) ? s.ai.provider
+      : (envProvider && isProviderId(envProvider) ? envProvider : 'anthropic'));
+
+  const preset = PROVIDER_PRESETS[provider] ?? PROVIDER_PRESETS.anthropic;
+  const provCfg = s.ai.providers[provider] ?? { apiKey: '', model: '' };
+
+  const apiKey = provCfg.apiKey
+    || getApiKeyFromEnv(provider)
+    || preset.apiKeyFallback
+    || '';
+  const model = provCfg.model
+    || preset.defaultModel;
+  const baseUrl = provCfg.baseUrl
+    || preset.fixedBaseUrl
+    || '';
+
+  return { provider, apiKey, model, baseUrl };
 }
 
 /** Effective MIND_ROOT — settings file can override, env var is fallback */

package/app/lib/space-ai-init.ts

@@ -0,0 +1,66 @@
+import { apiFetch } from '@/lib/api';
+
+/**
+ * Check if AI is available by inspecting the active provider's API key.
+ */
+export async function checkAiAvailable(): Promise<boolean> {
+  try {
+    const data = await apiFetch<{
+      ai?: { provider?: string; providers?: Record<string, { apiKey?: string }> };
+    }>('/api/settings');
+    const provider = data.ai?.provider ?? '';
+    const providers = data.ai?.providers ?? {};
+    const active = providers[provider as keyof typeof providers];
+    return !!(active?.apiKey);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Trigger AI to generate README.md and INSTRUCTION.md for a space.
+ * Dispatches `mindos:ai-init` events consumed by SpaceInitToast.
+ * The call is fire-and-forget — returns immediately after starting the stream.
+ */
+export function triggerSpaceAiInit(
+  spaceName: string,
+  spacePath: string,
+  description = '',
+): void {
+  const isZh = typeof document !== 'undefined' && document.documentElement.lang === 'zh';
+  const prompt = isZh
+    ? `初始化新建的心智空间「${spaceName}」，路径为「${spacePath}/」。${description ? `描述：「${description}」。` : ''}两个文件均已存在模板，用 write_file 覆盖：\n1. 「${spacePath}/README.md」— 写入空间用途、结构概览、使用指南\n2. 「${spacePath}/INSTRUCTION.md」— 写入 AI Agent 在此空间中的行为规则和操作约定\n\n内容简洁实用，直接使用工具写入。`
+    : `Initialize the new Mind Space "${spaceName}" at "${spacePath}/". ${description ? `Description: "${description}". ` : ''}Both files already exist with templates — use write_file to overwrite:\n1. "${spacePath}/README.md" — write purpose, structure overview, usage guidelines\n2. "${spacePath}/INSTRUCTION.md" — write rules for AI agents operating in this space\n\nKeep content concise and actionable. Write files directly using tools.`;
+
+  window.dispatchEvent(new CustomEvent('mindos:ai-init', {
+    detail: { spaceName, spacePath, description, state: 'working' },
+  }));
+
+  fetch('/api/ask', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      messages: [{ role: 'user', content: prompt }],
+      currentFile: spacePath + '/INSTRUCTION.md',
+    }),
+  }).then(async (res) => {
+    if (!res.ok || !res.body) throw new Error(`HTTP ${res.status}`);
+    const reader = res.body.getReader();
+    try {
+      while (true) {
+        const { done } = await reader.read();
+        if (done) break;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    window.dispatchEvent(new CustomEvent('mindos:ai-init', {
+      detail: { spacePath, state: 'done' },
+    }));
+    window.dispatchEvent(new Event('mindos:files-changed'));
+  }).catch(() => {
+    window.dispatchEvent(new CustomEvent('mindos:ai-init', {
+      detail: { spacePath, state: 'error' },
+    }));
+  });
+}

package/app/lib/stores/LocaleStoreInit.tsx

@@ -0,0 +1,18 @@
+'use client';
+
+import { useEffect } from 'react';
+import { useLocaleStore } from '@/lib/stores/locale-store';
+import type { Locale } from '@/lib/i18n';
+
+/**
+ * Initializes locale store with SSR value and attaches event listeners.
+ * Renders nothing. Place once near the root.
+ */
+export default function LocaleStoreInit({ ssrLocale }: { ssrLocale: Locale }) {
+  useEffect(() => {
+    const cleanup = useLocaleStore.getState()._init(ssrLocale);
+    return cleanup;
+  }, [ssrLocale]);
+
+  return null;
+}

package/app/lib/stores/McpStoreInit.tsx

@@ -0,0 +1,18 @@
+'use client';
+
+import { useEffect } from 'react';
+import { useMcpStore } from '@/lib/stores/mcp-store';
+
+/**
+ * Thin component that initializes MCP store side-effects (polling, event listeners).
+ * Renders nothing — drop it anywhere in the tree that needs MCP data.
+ * Replaces the old <McpProvider> wrapper.
+ */
+export default function McpStoreInit() {
+  useEffect(() => {
+    const cleanup = useMcpStore.getState()._init();
+    return cleanup;
+  }, []);
+
+  return null;
+}

package/app/lib/stores/WalkthroughInit.tsx

@@ -0,0 +1,20 @@
+'use client';
+
+import { useEffect } from 'react';
+import { useWalkthroughStore } from '@/lib/stores/walkthrough-store';
+import WalkthroughOverlay from '@/components/walkthrough/WalkthroughOverlay';
+
+/**
+ * Initializes walkthrough store and conditionally renders the overlay.
+ * Replaces the old <WalkthroughProvider> wrapper.
+ */
+export default function WalkthroughInit() {
+  useEffect(() => {
+    const cleanup = useWalkthroughStore.getState()._init();
+    return cleanup;
+  }, []);
+
+  const status = useWalkthroughStore(s => s.status);
+
+  return status === 'active' ? <WalkthroughOverlay /> : null;
+}

package/app/lib/stores/locale-store.ts

@@ -0,0 +1,55 @@
+'use client';
+
+import { create } from 'zustand';
+import { Locale, messages, Messages } from '@/lib/i18n';
+
+/* ── Store ── */
+
+export interface LocaleStoreState {
+  locale: Locale;
+  t: Messages;
+  setLocale: (l: Locale) => void;
+  /** Hydrate from SSR value + attach listeners. Returns cleanup. */
+  _init: (ssrLocale: Locale) => () => void;
+}
+
+/** Read locale from localStorage, resolving 'system' */
+function getLocaleSnapshot(): Locale {
+  if (typeof window === 'undefined') return 'en';
+  const saved = localStorage.getItem('locale');
+  if (saved === 'zh') return 'zh';
+  if (saved === 'en') return 'en';
+  return navigator.language.startsWith('zh') ? 'zh' : 'en';
+}
+
+export const useLocaleStore = create<LocaleStoreState>((set) => ({
+  locale: 'en',
+  t: messages['en'] as unknown as Messages,
+
+  setLocale: (l: Locale) => {
+    document.cookie = `locale=${l};path=/;max-age=31536000;SameSite=Lax`;
+    document.documentElement.lang = l === 'zh' ? 'zh' : 'en';
+    set({ locale: l, t: messages[l] as unknown as Messages });
+    window.dispatchEvent(new Event('mindos-locale-change'));
+  },
+
+  _init: (ssrLocale: Locale) => {
+    // Hydrate with client value (or SSR fallback)
+    const clientLocale = typeof window !== 'undefined' ? getLocaleSnapshot() : ssrLocale;
+    set({ locale: clientLocale, t: messages[clientLocale] as unknown as Messages });
+
+    // Listen for external changes (e.g. localStorage change in another tab, or pre-hydration script)
+    const handler = () => {
+      const l = getLocaleSnapshot();
+      set({ locale: l, t: messages[l] as unknown as Messages });
+    };
+    window.addEventListener('mindos-locale-change', handler);
+    return () => window.removeEventListener('mindos-locale-change', handler);
+  },
+}));
+
+/* ── Backward-compatible hook ── */
+
+export function useLocale() {
+  return useLocaleStore();
+}

package/app/lib/stores/mcp-store.ts

@@ -0,0 +1,156 @@
+'use client';
+
+import { create } from 'zustand';
+import { apiFetch } from '@/lib/api';
+import type { McpStatus, AgentInfo, SkillInfo } from '@/components/settings/types';
+
+/* ── Public interface (unchanged from old Context) ── */
+
+export interface McpStoreState {
+  status: McpStatus | null;
+  agents: AgentInfo[];
+  skills: SkillInfo[];
+  loading: boolean;
+
+  /* actions */
+  refresh: () => Promise<void>;
+  toggleSkill: (name: string, enabled: boolean) => Promise<boolean>;
+  installAgent: (key: string, opts?: { scope?: string; transport?: string }) => Promise<boolean>;
+
+  /* lifecycle (called once by McpStoreInit) */
+  _init: () => () => void;
+}
+
+/** Keep the old name as an alias so consumers that import the type still compile. */
+export type McpContextValue = McpStoreState;
+
+/* ── Abort controller for race-condition safety ── */
+
+let abortCtrl: AbortController | null = null;
+
+/* ── Store ── */
+
+const POLL_INTERVAL = 30_000;
+
+async function fetchAll(set: (partial: Partial<McpStoreState>) => void) {
+  abortCtrl?.abort();
+  const ac = new AbortController();
+  abortCtrl = ac;
+
+  try {
+    const [statusData, agentsData, skillsData] = await Promise.all([
+      apiFetch<McpStatus>('/api/mcp/status', { signal: ac.signal }),
+      apiFetch<{ agents: AgentInfo[] }>('/api/mcp/agents', { signal: ac.signal }),
+      apiFetch<{ skills: SkillInfo[] }>('/api/skills', { signal: ac.signal }),
+    ]);
+    if (!ac.signal.aborted) {
+      set({ status: statusData, agents: agentsData.agents, skills: skillsData.skills });
+    }
+  } catch (err: unknown) {
+    if (err instanceof DOMException && err.name === 'AbortError') return;
+  } finally {
+    if (!ac.signal.aborted) set({ loading: false });
+  }
+}
+
+export const useMcpStore = create<McpStoreState>((set, get) => ({
+  status: null,
+  agents: [],
+  skills: [],
+  loading: true,
+
+  refresh: () => fetchAll(set),
+
+  toggleSkill: async (name, enabled) => {
+    // Optimistic update
+    set({ skills: get().skills.map(s => s.name === name ? { ...s, enabled } : s) });
+    try {
+      await apiFetch('/api/skills', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'toggle', name, enabled }),
+      });
+      return true;
+    } catch {
+      // Revert on failure
+      set({ skills: get().skills.map(s => s.name === name ? { ...s, enabled: !enabled } : s) });
+      return false;
+    }
+  },
+
+  installAgent: async (key, opts) => {
+    const agent = get().agents.find(a => a.key === key);
+    if (!agent) return false;
+
+    try {
+      const res = await apiFetch<{ results: Array<{ agent?: string; status?: string; ok?: boolean; error?: string }> }>('/api/mcp/install', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          agents: [{
+            key,
+            scope: opts?.scope ?? (agent.hasProjectScope ? 'project' : 'global'),
+            transport: opts?.transport ?? agent.preferredTransport,
+          }],
+          transport: 'auto',
+        }),
+      });
+
+      const first = res.results?.[0];
+      const ok = first?.ok === true || first?.status === 'ok';
+      if (ok) await fetchAll(set);
+      return ok;
+    } catch {
+      return false;
+    }
+  },
+
+  /**
+   * Start polling + event listeners. Returns a cleanup function.
+   * Must be called exactly once (by McpStoreInit).
+   */
+  _init: () => {
+    // Initial fetch
+    fetchAll(set);
+
+    // Event listener: skill CRUD mutations (debounced 500ms)
+    let debounceTimer: ReturnType<typeof setTimeout> | undefined;
+    const onSkillsChanged = () => {
+      clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => fetchAll(set), 500);
+    };
+    window.addEventListener('mindos:skills-changed', onSkillsChanged);
+
+    // 30s polling when visible
+    const pollTimer = setInterval(() => {
+      if (document.visibilityState === 'visible') fetchAll(set);
+    }, POLL_INTERVAL);
+
+    return () => {
+      abortCtrl?.abort();
+      clearTimeout(debounceTimer);
+      clearInterval(pollTimer);
+      window.removeEventListener('mindos:skills-changed', onSkillsChanged);
+    };
+  },
+}));
+
+/* ── Convenience hooks (backward-compatible API) ── */
+
+/**
+ * Required hook — same behavior as old useMcpData().
+ * With Zustand this never throws because the store is global,
+ * but we keep the name for migration compatibility.
+ */
+export function useMcpData(): McpStoreState {
+  return useMcpStore();
+}
+
+/**
+ * Optional hook — returns the full store (never null with Zustand).
+ * Kept for backward-compat; callers that checked `if (!mcp)` will
+ * now always get a value (loading=true initially, then loading=false).
+ */
+export function useMcpDataOptional(): McpStoreState {
+  return useMcpStore();
+}

package/app/lib/stores/walkthrough-store.ts

@@ -0,0 +1,118 @@
+'use client';
+
+import { create } from 'zustand';
+import { walkthroughSteps } from '@/components/walkthrough/steps';
+
+/* ── Types ── */
+
+export type WalkthroughStatus = 'idle' | 'active' | 'completed' | 'dismissed';
+
+export interface WalkthroughStoreState {
+  status: WalkthroughStatus;
+  currentStep: number;
+  totalSteps: number;
+  start: () => void;
+  next: () => void;
+  back: () => void;
+  skip: () => void;
+  /** Called once to load from backend + attach URL param check. Returns cleanup. */
+  _init: () => () => void;
+}
+
+/* ── Helpers ── */
+
+function persistStep(step: number, dismissed: boolean) {
+  fetch('/api/setup', {
+    method: 'PATCH',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      guideState: { walkthroughStep: step, walkthroughDismissed: dismissed },
+    }),
+  }).catch((err) => { console.warn('[walkthrough-store] persist failed:', err); });
+}
+
+/* ── Store ── */
+
+export const useWalkthroughStore = create<WalkthroughStoreState>((set, get) => {
+  const totalSteps = walkthroughSteps.length;
+
+  return {
+    status: 'idle',
+    currentStep: 0,
+    totalSteps,
+
+    start: () => {
+      set({ currentStep: 0, status: 'active' });
+      persistStep(0, false);
+    },
+
+    next: () => {
+      const nextStep = get().currentStep + 1;
+      if (nextStep >= totalSteps) {
+        set({ status: 'completed' });
+        persistStep(totalSteps, false);
+      } else {
+        set({ currentStep: nextStep });
+        persistStep(nextStep, false);
+      }
+    },
+
+    back: () => {
+      const cur = get().currentStep;
+      if (cur > 0) {
+        set({ currentStep: cur - 1 });
+        persistStep(cur - 1, false);
+      }
+    },
+
+    skip: () => {
+      set({ status: 'dismissed' });
+      persistStep(get().currentStep, true);
+    },
+
+    _init: () => {
+      // Handle ?welcome=1 URL param
+      const params = new URLSearchParams(window.location.search);
+      const isWelcome = params.get('welcome') === '1';
+      if (isWelcome) {
+        const url = new URL(window.location.href);
+        url.searchParams.delete('welcome');
+        window.history.replaceState({}, '', url.pathname + (url.search || ''));
+        window.dispatchEvent(new Event('mindos:first-visit'));
+      }
+
+      // Only auto-start on desktop
+      if (window.innerWidth < 768) return () => {};
+
+      fetch('/api/setup')
+        .then(r => r.json())
+        .then(data => {
+          const gs = data.guideState;
+          if (!gs) return;
+          if (gs.walkthroughDismissed) return;
+
+          if (gs.active && !gs.dismissed && gs.walkthroughStep === undefined) {
+            if (isWelcome) {
+              set({ status: 'active', currentStep: 0 });
+            }
+          } else if (
+            typeof gs.walkthroughStep === 'number' &&
+            gs.walkthroughStep >= 0 &&
+            gs.walkthroughStep < totalSteps &&
+            !gs.walkthroughDismissed
+          ) {
+            set({ status: 'active', currentStep: gs.walkthroughStep });
+          }
+        })
+        .catch((err) => { console.warn('[walkthrough-store] guideState read failed:', err); });
+
+      return () => {};
+    },
+  };
+});
+
+/* ── Backward-compatible hook ── */
+
+export function useWalkthrough(): WalkthroughStoreState {
+  return useWalkthroughStore();
+}

package/app/lib/types.ts

@@ -1,6 +1,19 @@
 // Re-export core types as single source of truth
 export type { FileNode, SearchResult, BacklinkEntry } from './core/types';
 
+/** System configuration files that should be hidden from file tree by default */
+export const SYSTEM_FILES = new Set([
+  'INSTRUCTION.md',
+  'README.md',
+  'CONFIG.json',
+  'CHANGELOG.md',
+]);
+
+/** Root-level files that users can see but cannot delete */
+export const UNDELETABLE_FILES = new Set([
+  'TODO.md',
+]);
+
 export interface SearchMatch {
   indices: [number, number][];
   value: string;
@@ -61,8 +74,15 @@ export interface LocalAttachment {
   content: string;
 }
 
+/** User-facing Ask modes. 'organize' is internal-only (not selectable by users). */
+export type AskMode = 'chat' | 'agent';
+
+/** All Ask modes including internal ones sent to the API */
+export type AskModeApi = AskMode | 'organize';
+
 export interface ChatSession {
   id: string;
+  title?: string;
   currentFile?: string;
   createdAt: number;
   updatedAt: number;

package/app/package.json

@@ -11,6 +11,7 @@
     "start": "next start -p ${MINDOS_WEB_PORT:-3456}",
     "lint": "eslint",
     "test": "vitest run",
+    "typecheck": "tsc --noEmit",
     "postinstall": "node ../scripts/fix-postcss-deps.cjs"
   },
   "dependencies": {
@@ -66,7 +67,8 @@
     "tailwind-merge": "^3.5.0",
     "tiptap-markdown": "^0.9.0",
     "tw-animate-css": "^1.4.0",
-    "zod": "^3.23.8"
+    "zod": "^3.23.8",
+    "zustand": "^5.0.12"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",

package/app/tsconfig.json

@@ -30,5 +30,5 @@
     ".next/dev/types/**/*.ts",
     "**/*.mts"
   ],
-  "exclude": ["node_modules"]
+  "exclude": ["node_modules", "__tests__"]
 }