@geminilight/mindos 0.5.18 → 0.5.20

package/app/app/api/ask/route.ts

@@ -57,11 +57,12 @@ function convertToModelMessages(messages: FrontendMessage[]): ModelMessage[] {
           type: 'tool-call',
           toolCallId: part.toolCallId,
           toolName: part.toolName,
-          input: part.input,
+          input: part.input ?? {},
         });
-        if (part.state === 'done' || part.state === 'error') {
-          completedToolCalls.push(part);
-        }
+        // Always emit a tool result for every tool call. Orphaned tool calls
+        // (running/pending from interrupted streams) get an empty result;
+        // without one the API rejects the request.
+        completedToolCalls.push(part);
       }
       // 'reasoning' parts are display-only; not sent back to model
     }

package/app/app/api/file/route.ts

@@ -1,5 +1,6 @@
 export const dynamic = 'force-dynamic';
 import { NextRequest, NextResponse } from 'next/server';
+import { revalidatePath } from 'next/cache';
 import {
   getFileContent,
   saveFileContent,
@@ -37,6 +38,9 @@ export async function GET(req: NextRequest) {
   }
 }
 
+// Ops that change file tree structure (sidebar needs refresh)
+const TREE_CHANGING_OPS = new Set(['create_file', 'delete_file', 'rename_file', 'move_file']);
+
 // POST /api/file  body: { op, path, ...params }
 export async function POST(req: NextRequest) {
   let body: Record<string, unknown>;
@@ -47,20 +51,24 @@ export async function POST(req: NextRequest) {
   if (!filePath || typeof filePath !== 'string') return err('missing path');
 
   try {
+    let resp: NextResponse;
+
     switch (op) {
 
       case 'save_file': {
         const { content } = params as { content: string };
         if (typeof content !== 'string') return err('missing content');
         saveFileContent(filePath, content);
-        return NextResponse.json({ ok: true });
+        resp = NextResponse.json({ ok: true });
+        break;
       }
 
       case 'append_to_file': {
         const { content } = params as { content: string };
         if (typeof content !== 'string') return err('missing content');
         appendToFile(filePath, content);
-        return NextResponse.json({ ok: true });
+        resp = NextResponse.json({ ok: true });
+        break;
       }
 
       case 'insert_lines': {
@@ -68,7 +76,8 @@ export async function POST(req: NextRequest) {
         if (typeof after_index !== 'number') return err('missing after_index');
         if (!Array.isArray(lines)) return err('lines must be array');
         insertLines(filePath, after_index, lines);
-        return NextResponse.json({ ok: true });
+        resp = NextResponse.json({ ok: true });
+        break;
       }
 
       case 'update_lines': {
@@ -78,7 +87,8 @@ export async function POST(req: NextRequest) {
         if (start < 0 || end < 0) return err('start/end must be >= 0');
         if (start > end) return err('start must be <= end');
         updateLines(filePath, start, end, lines);
-        return NextResponse.json({ ok: true });
+        resp = NextResponse.json({ ok: true });
+        break;
       }
 
       case 'insert_after_heading': {
@@ -86,7 +96,8 @@ export async function POST(req: NextRequest) {
         if (typeof heading !== 'string') return err('missing heading');
         if (typeof content !== 'string') return err('missing content');
         insertAfterHeading(filePath, heading, content);
-        return NextResponse.json({ ok: true });
+        resp = NextResponse.json({ ok: true });
+        break;
       }
 
       case 'update_section': {
@@ -94,44 +105,57 @@ export async function POST(req: NextRequest) {
         if (typeof heading !== 'string') return err('missing heading');
         if (typeof content !== 'string') return err('missing content');
         updateSection(filePath, heading, content);
-        return NextResponse.json({ ok: true });
+        resp = NextResponse.json({ ok: true });
+        break;
       }
 
       case 'delete_file': {
         deleteFile(filePath);
-        return NextResponse.json({ ok: true });
+        resp = NextResponse.json({ ok: true });
+        break;
       }
 
       case 'rename_file': {
         const { new_name } = params as { new_name: string };
         if (typeof new_name !== 'string' || !new_name) return err('missing new_name');
         const newPath = renameFile(filePath, new_name);
-        return NextResponse.json({ ok: true, newPath });
+        resp = NextResponse.json({ ok: true, newPath });
+        break;
       }
 
       case 'create_file': {
         const { content } = params as { content?: string };
         createFile(filePath, typeof content === 'string' ? content : '');
-        return NextResponse.json({ ok: true });
+        resp = NextResponse.json({ ok: true });
+        break;
       }
 
       case 'move_file': {
         const { to_path } = params as { to_path: string };
         if (typeof to_path !== 'string' || !to_path) return err('missing to_path');
         const result = moveFile(filePath, to_path);
-        return NextResponse.json({ ok: true, ...result });
+        resp = NextResponse.json({ ok: true, ...result });
+        break;
       }
 
       case 'append_csv': {
         const { row } = params as { row: string[] };
         if (!Array.isArray(row) || row.length === 0) return err('row must be non-empty array');
         const result = appendCsvRow(filePath, row);
-        return NextResponse.json({ ok: true, ...result });
+        resp = NextResponse.json({ ok: true, ...result });
+        break;
       }
 
       default:
         return err(`unknown op: ${op}`);
     }
+
+    // Invalidate Next.js router cache so sidebar file tree updates
+    if (TREE_CHANGING_OPS.has(op)) {
+      try { revalidatePath('/', 'layout'); } catch { /* noop in test env */ }
+    }
+
+    return resp;
   } catch (e) {
     return err((e as Error).message, 500);
   }

package/app/app/api/setup/route.ts

@@ -30,6 +30,7 @@ export async function GET() {
       openaiApiKey: maskApiKey(s.ai.providers.openai.apiKey),
       openaiModel: s.ai.providers.openai.model,
       openaiBaseUrl: s.ai.providers.openai.baseUrl ?? '',
+      guideState: s.guideState ?? null,
     });
   } catch (e) {
     return NextResponse.json(
@@ -95,9 +96,33 @@ export async function POST(req: NextRequest) {
     );
 
     // Build config
+    // Merge AI config: empty apiKey means "keep existing" — never overwrite a
+    // configured key with blank just because the user didn't re-enter it.
+    let mergedAi = current.ai;
+    if (ai) {
+      const inAnthropicKey = ai.providers?.anthropic?.apiKey;
+      const inOpenaiKey    = ai.providers?.openai?.apiKey;
+      mergedAi = {
+        provider: ai.provider ?? current.ai.provider,
+        providers: {
+          anthropic: {
+            apiKey: inAnthropicKey || current.ai.providers.anthropic.apiKey,
+            model:  ai.providers?.anthropic?.model || current.ai.providers.anthropic.model,
+          },
+          openai: {
+            apiKey:  inOpenaiKey || current.ai.providers.openai.apiKey,
+            model:   ai.providers?.openai?.model  || current.ai.providers.openai.model,
+            baseUrl: ai.providers?.openai?.baseUrl ?? current.ai.providers.openai.baseUrl ?? '',
+          },
+        },
+      };
+    }
+
     const disabledSkills = body.template === 'zh' ? ['mindos'] : ['mindos-zh'];
+    // Determine guide template from setup template
+    const guideTemplate = body.template === 'zh' ? 'zh' : body.template === 'empty' ? 'empty' : 'en';
     const config: ServerSettings = {
-      ai: ai ?? current.ai,
+      ai: mergedAi,
       mindRoot: resolvedRoot,
       port: webPort,
       mcpPort: mcpPortNum,
@@ -106,6 +131,14 @@ export async function POST(req: NextRequest) {
       startMode: current.startMode,
       setupPending: false,  // clear the flag
       disabledSkills,
+      guideState: {
+        active: true,
+        dismissed: false,
+        template: guideTemplate as 'en' | 'zh' | 'empty',
+        step1Done: false,
+        askedAI: false,
+        nextStepIndex: 0,
+      },
     };
 
     writeSettings(config);
@@ -124,3 +157,33 @@ export async function POST(req: NextRequest) {
     );
   }
 }
+
+export async function PATCH(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { guideState: patch } = body;
+    if (!patch || typeof patch !== 'object') {
+      return NextResponse.json({ error: 'guideState object required' }, { status: 400 });
+    }
+    const current = readSettings();
+    const existing = current.guideState ?? {
+      active: false, dismissed: false, template: 'en' as const,
+      step1Done: false, askedAI: false, nextStepIndex: 0,
+    };
+    // Merge only known fields
+    const updated = { ...existing };
+    if (typeof patch.dismissed === 'boolean') updated.dismissed = patch.dismissed;
+    if (typeof patch.step1Done === 'boolean') updated.step1Done = patch.step1Done;
+    if (typeof patch.askedAI === 'boolean') updated.askedAI = patch.askedAI;
+    if (typeof patch.nextStepIndex === 'number' && patch.nextStepIndex >= 0) updated.nextStepIndex = patch.nextStepIndex;
+    if (typeof patch.active === 'boolean') updated.active = patch.active;
+
+    writeSettings({ ...current, guideState: updated });
+    return NextResponse.json({ ok: true, guideState: updated });
+  } catch (e) {
+    return NextResponse.json(
+      { error: e instanceof Error ? e.message : String(e) },
+      { status: 500 },
+    );
+  }
+}

package/app/app/api/skills/route.ts

@@ -129,7 +129,7 @@ export async function POST(req: NextRequest) {
   try {
     const body = await req.json();
     const { action, name, description, content, enabled } = body as {
-      action: 'create' | 'update' | 'delete' | 'toggle';
+      action: 'create' | 'update' | 'delete' | 'toggle' | 'read';
       name?: string;
       description?: string;
       content?: string;
@@ -172,8 +172,11 @@ export async function POST(req: NextRequest) {
           return NextResponse.json({ error: 'A skill with this name already exists' }, { status: 409 });
         }
         fs.mkdirSync(skillDir, { recursive: true });
-        const frontmatter = `---\nname: ${name}\ndescription: ${description || name}\n---\n\n${content || ''}`;
-        fs.writeFileSync(path.join(skillDir, 'SKILL.md'), frontmatter, 'utf-8');
+        // If content already has frontmatter, use it as-is; otherwise build frontmatter
+        const fileContent = content && content.trimStart().startsWith('---')
+          ? content
+          : `---\nname: ${name}\ndescription: ${description || name}\n---\n\n${content || ''}`;
+        fs.writeFileSync(path.join(skillDir, 'SKILL.md'), fileContent, 'utf-8');
         return NextResponse.json({ ok: true });
       }
 
@@ -199,6 +202,22 @@ export async function POST(req: NextRequest) {
         return NextResponse.json({ ok: true });
       }
 
+      case 'read': {
+        if (!name) return NextResponse.json({ error: 'name required' }, { status: 400 });
+        const dirs = [
+          path.join(PROJECT_ROOT, 'app', 'data', 'skills', name),
+          path.join(PROJECT_ROOT, 'skills', name),
+          path.join(userSkillsDir, name),
+        ];
+        for (const dir of dirs) {
+          const file = path.join(dir, 'SKILL.md');
+          if (fs.existsSync(file)) {
+            return NextResponse.json({ content: fs.readFileSync(file, 'utf-8') });
+          }
+        }
+        return NextResponse.json({ error: 'Skill not found' }, { status: 404 });
+      }
+
       default:
         return NextResponse.json({ error: `Unknown action: ${action}` }, { status: 400 });
     }

package/app/app/globals.css

@@ -288,6 +288,7 @@ body {
 /* Micro type scale: text-2xs = 10px (between nothing and text-xs 12px) */
 @layer utilities {
   .text-2xs { font-size: 10px; line-height: 1.4; }
+  .animate-spin-slow { animation: spin 3s linear infinite; }
 }
 
 /* Hide scrollbar but keep scroll functionality */

package/app/components/AskFab.tsx

@@ -1,9 +1,10 @@
 'use client';
 
-import { useState } from 'react';
+import { useState, useEffect, useCallback } from 'react';
 import { usePathname } from 'next/navigation';
 import { Sparkles } from 'lucide-react';
 import AskModal from './AskModal';
+import { useAskModal } from '@/hooks/useAskModal';
 
 export default function AskFab() {
   const [open, setOpen] = useState(false);
@@ -12,10 +13,49 @@ export default function AskFab() {
     ? pathname.slice('/view/'.length).split('/').map(decodeURIComponent).join('/')
     : undefined;
 
+  // Listen to useAskModal store for cross-component open requests (e.g. from GuideCard)
+  const askModal = useAskModal();
+  const [initialMessage, setInitialMessage] = useState('');
+  const [openSource, setOpenSource] = useState<'user' | 'guide' | 'guide-next'>('user');
+
+  useEffect(() => {
+    if (askModal.open) {
+      setInitialMessage(askModal.initialMessage);
+      setOpenSource(askModal.source);
+      setOpen(true);
+      askModal.close(); // Reset store state after consuming
+    }
+  }, [askModal.open, askModal.initialMessage, askModal.source, askModal.close]);
+
+  const handleClose = useCallback(() => {
+    setOpen(false);
+    setInitialMessage('');
+    setOpenSource('user');
+  }, []);
+
+  // Dispatch correct PATCH based on how the modal was opened
+  const handleFirstMessage = useCallback(() => {
+    const notifyGuide = () => window.dispatchEvent(new Event('guide-state-updated'));
+
+    if (openSource === 'guide') {
+      // Task ② completion: mark askedAI
+      fetch('/api/setup', {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ guideState: { askedAI: true } }),
+      }).then(notifyGuide).catch(() => {});
+    } else if (openSource === 'guide-next') {
+      // Next-step advancement: GuideCard already PATCHed nextStepIndex optimistically.
+      // Just notify GuideCard to re-fetch for consistency; no additional PATCH needed.
+      notifyGuide();
+    }
+    // For 'user' source: no guide action needed
+  }, [openSource]);
+
   return (
     <>
       <button
-        onClick={() => setOpen(true)}
+        onClick={() => { setInitialMessage(''); setOpenSource('user'); setOpen(true); }}
         className="
           group
           fixed z-40
@@ -53,7 +93,13 @@ export default function AskFab() {
         </span>
       </button>
 
-      <AskModal open={open} onClose={() => setOpen(false)} currentFile={currentFile} />
+      <AskModal
+        open={open}
+        onClose={handleClose}
+        currentFile={currentFile}
+        initialMessage={initialMessage}
+        onFirstMessage={handleFirstMessage}
+      />
     </>
   );
 }

package/app/components/AskModal.tsx

@@ -17,11 +17,14 @@ interface AskModalProps {
   open: boolean;
   onClose: () => void;
   currentFile?: string;
+  initialMessage?: string;
+  onFirstMessage?: () => void;
 }
 
-export default function AskModal({ open, onClose, currentFile }: AskModalProps) {
+export default function AskModal({ open, onClose, currentFile, initialMessage, onFirstMessage }: AskModalProps) {
   const inputRef = useRef<HTMLInputElement>(null);
   const abortRef = useRef<AbortController | null>(null);
+  const firstMessageFired = useRef(false);
   const { t } = useLocale();
 
   const [input, setInput] = useState('');
@@ -43,7 +46,8 @@ export default function AskModal({ open, onClose, currentFile }: AskModalProps)
         if (cancelled) return;
         await session.initSessions();
       })();
-      setInput('');
+      setInput(initialMessage || '');
+      firstMessageFired.current = false;
       setAttachedFiles(currentFile ? [currentFile] : []);
       upload.clearAttachments();
       mention.resetMention();
@@ -119,6 +123,11 @@ export default function AskModal({ open, onClose, currentFile }: AskModalProps)
     const requestMessages = [...session.messages, userMsg];
     session.setMessages([...requestMessages, { role: 'assistant', content: '' }]);
     setInput('');
+    // Notify guide card on first user message (ref prevents duplicate fires during re-render)
+    if (onFirstMessage && !firstMessageFired.current) {
+      firstMessageFired.current = true;
+      onFirstMessage();
+    }
     setAttachedFiles(currentFile ? [currentFile] : []);
     setIsLoading(true);
     setLoadingPhase('connecting');