@geminilight/mindos 0.5.10 → 0.5.12

package/app/components/ask/MessageList.tsx

@@ -1,10 +1,11 @@
 'use client';
 
 import { useRef, useEffect } from 'react';
-import { Sparkles, Loader2, AlertCircle } from 'lucide-react';
+import { Sparkles, Loader2, AlertCircle, Wrench } from 'lucide-react';
 import ReactMarkdown from 'react-markdown';
 import remarkGfm from 'remark-gfm';
 import type { Message } from '@/lib/types';
+import ToolCallBlock from './ToolCallBlock';
 
 function AssistantMessage({ content, isStreaming }: { content: string; isStreaming: boolean }) {
   return (
@@ -28,6 +29,57 @@ function AssistantMessage({ content, isStreaming }: { content: string; isStreami
   );
 }
 
+function AssistantMessageWithParts({ message, isStreaming }: { message: Message; isStreaming: boolean }) {
+  const parts = message.parts;
+  if (!parts || parts.length === 0) {
+    // Fallback to plain text rendering
+    return message.content ? (
+      <AssistantMessage content={message.content} isStreaming={isStreaming} />
+    ) : null;
+  }
+
+  // Check if the last part is a running tool call — show a spinner after it
+  const lastPart = parts[parts.length - 1];
+  const showTrailingSpinner = isStreaming && lastPart.type === 'tool-call' && (lastPart.state === 'running' || lastPart.state === 'pending');
+
+  return (
+    <div>
+      {parts.map((part, idx) => {
+        if (part.type === 'text') {
+          const isLastTextPart = isStreaming && idx === parts.length - 1;
+          return part.text ? (
+            <AssistantMessage key={idx} content={part.text} isStreaming={isLastTextPart} />
+          ) : null;
+        }
+        if (part.type === 'tool-call') {
+          return <ToolCallBlock key={part.toolCallId} part={part} />;
+        }
+        return null;
+      })}
+      {showTrailingSpinner && (
+        <div className="flex items-center gap-2 py-1 mt-1">
+          <Loader2 size={12} className="animate-spin" style={{ color: 'var(--amber)' }} />
+          <span className="text-xs text-muted-foreground animate-pulse">Executing tool…</span>
+        </div>
+      )}
+    </div>
+  );
+}
+
+function StepCounter({ parts, maxSteps }: { parts: Message['parts']; maxSteps?: number }) {
+  if (!parts) return null;
+  const toolCalls = parts.filter(p => p.type === 'tool-call');
+  if (toolCalls.length === 0) return null;
+  const lastToolCall = toolCalls[toolCalls.length - 1];
+  const toolLabel = lastToolCall.type === 'tool-call' ? lastToolCall.toolName : '';
+  return (
+    <div className="flex items-center gap-1.5 mt-1.5 text-xs text-muted-foreground/70">
+      <Wrench size={10} />
+      <span>Step {toolCalls.length}{maxSteps ? `/${maxSteps}` : ''}{toolLabel ? ` — ${toolLabel}` : ''}</span>
+    </div>
+  );
+}
+
 interface MessageListProps {
   messages: Message[];
   isLoading: boolean;
@@ -35,6 +87,7 @@ interface MessageListProps {
   emptyPrompt: string;
   suggestions: readonly string[];
   onSuggestionClick: (text: string) => void;
+  maxSteps?: number;
   labels: {
     connecting: string;
     thinking: string;
@@ -49,6 +102,7 @@ export default function MessageList({
   emptyPrompt,
   suggestions,
   onSuggestionClick,
+  maxSteps,
   labels,
 }: MessageListProps) {
   const endRef = useRef<HTMLDivElement>(null);
@@ -102,8 +156,13 @@ export default function MessageList({
             </div>
           ) : (
             <div className="max-w-[85%] px-3 py-2 rounded-xl rounded-bl-sm bg-muted text-foreground text-sm">
-              {m.content ? (
-                <AssistantMessage content={m.content} isStreaming={isLoading && i === messages.length - 1} />
+              {(m.parts && m.parts.length > 0) || m.content ? (
+                <>
+                  <AssistantMessageWithParts message={m} isStreaming={isLoading && i === messages.length - 1} />
+                  {isLoading && i === messages.length - 1 && (
+                    <StepCounter parts={m.parts} maxSteps={maxSteps} />
+                  )}
+                </>
               ) : isLoading && i === messages.length - 1 ? (
                 <div className="flex items-center gap-2 py-1">
                   <Loader2 size={14} className="animate-spin" style={{ color: 'var(--amber)' }} />

package/app/components/ask/ToolCallBlock.tsx

@@ -0,0 +1,89 @@
+'use client';
+
+import { useState } from 'react';
+import { ChevronRight, ChevronDown, Loader2, CheckCircle2, XCircle } from 'lucide-react';
+import type { ToolCallPart } from '@/lib/types';
+
+const TOOL_ICONS: Record<string, string> = {
+  search: '🔍',
+  list_files: '📂',
+  read_file: '📖',
+  write_file: '✏️',
+  create_file: '📄',
+  append_to_file: '📝',
+  insert_after_heading: '📌',
+  update_section: '✏️',
+  delete_file: '🗑️',
+  rename_file: '📝',
+  move_file: '📦',
+  get_backlinks: '🔗',
+  get_history: '📜',
+  get_file_at_version: '⏪',
+  get_recent: '🕐',
+  append_csv: '📊',
+};
+
+function formatInput(input: unknown): string {
+  if (!input || typeof input !== 'object') return String(input ?? '');
+  const obj = input as Record<string, unknown>;
+  const parts: string[] = [];
+  for (const val of Object.values(obj)) {
+    if (typeof val === 'string') {
+      parts.push(val.length > 60 ? `${val.slice(0, 60)}…` : val);
+    } else if (Array.isArray(val)) {
+      parts.push(`[${val.length} items]`);
+    } else if (val !== undefined && val !== null) {
+      parts.push(String(val));
+    }
+  }
+  return parts.join(', ');
+}
+
+function truncateOutput(output: string, maxLen = 200): string {
+  if (output.length <= maxLen) return output;
+  return output.slice(0, maxLen) + '…';
+}
+
+export default function ToolCallBlock({ part }: { part: ToolCallPart }) {
+  const [expanded, setExpanded] = useState(false);
+  const icon = TOOL_ICONS[part.toolName] ?? '🔧';
+  const inputSummary = formatInput(part.input);
+
+  return (
+    <div className="my-1 rounded-md border border-border/50 bg-muted/30 text-xs font-mono">
+      <button
+        type="button"
+        onClick={() => setExpanded(v => !v)}
+        className="w-full flex items-center gap-1.5 px-2 py-1.5 text-left hover:bg-muted/50 transition-colors rounded-md"
+      >
+        {expanded ? <ChevronDown size={12} className="shrink-0 text-muted-foreground" /> : <ChevronRight size={12} className="shrink-0 text-muted-foreground" />}
+        <span>{icon}</span>
+        <span className="text-foreground font-medium">{part.toolName}</span>
+        <span className="text-muted-foreground truncate flex-1">({inputSummary})</span>
+        <span className="shrink-0 ml-auto">
+          {part.state === 'pending' || part.state === 'running' ? (
+            <Loader2 size={12} className="animate-spin text-amber-500" />
+          ) : part.state === 'done' ? (
+            <CheckCircle2 size={12} className="text-success" />
+          ) : (
+            <XCircle size={12} className="text-error" />
+          )}
+        </span>
+      </button>
+      {expanded && (
+        <div className="px-2 pb-2 pt-0.5 border-t border-border/30 space-y-1">
+          <div className="text-muted-foreground">
+            <span className="font-semibold">Input: </span>
+            <span className="break-all whitespace-pre-wrap">{JSON.stringify(part.input, null, 2)}</span>
+          </div>
+          {part.output !== undefined && (
+            <div className="text-muted-foreground">
+              <span className="font-semibold">Output: </span>
+              <span className="break-all whitespace-pre-wrap">{truncateOutput(part.output)}</span>
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  );
+}

package/app/components/settings/AiTab.tsx

@@ -1,9 +1,30 @@
 'use client';
 
-import { AlertCircle } from 'lucide-react';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { AlertCircle, Loader2 } from 'lucide-react';
 import type { AiSettings, ProviderConfig, SettingsData } from './types';
 import { Field, Select, Input, EnvBadge, ApiKeyInput } from './Primitives';
 
+type TestState = 'idle' | 'testing' | 'ok' | 'error';
+type ErrorCode = 'auth_error' | 'model_not_found' | 'rate_limited' | 'network_error' | 'unknown';
+
+interface TestResult {
+  state: TestState;
+  latency?: number;
+  error?: string;
+  code?: ErrorCode;
+}
+
+function errorMessage(t: any, code?: ErrorCode): string {
+  switch (code) {
+    case 'auth_error': return t.settings.ai.testKeyAuthError;
+    case 'model_not_found': return t.settings.ai.testKeyModelNotFound;
+    case 'rate_limited': return t.settings.ai.testKeyRateLimited;
+    case 'network_error': return t.settings.ai.testKeyNetworkError;
+    default: return t.settings.ai.testKeyUnknown;
+  }
+}
+
 interface AiTabProps {
   data: SettingsData;
   updateAi: (patch: Partial<AiSettings>) => void;
@@ -15,13 +36,76 @@ export function AiTab({ data, updateAi, t }: AiTabProps) {
   const envVal = data.envValues ?? {};
   const provider = data.ai.provider;
 
-  function patchProvider(name: 'anthropic' | 'openai', patch: Partial<ProviderConfig>) {
+  // --- Test key state ---
+  const [testResult, setTestResult] = useState<Record<string, TestResult>>({});
+  const okTimerRef = useRef<ReturnType<typeof setTimeout>>(undefined);
+  const prevProviderRef = useRef(provider);
+
+  // Reset test result when provider changes
+  useEffect(() => {
+    if (prevProviderRef.current !== provider) {
+      prevProviderRef.current = provider;
+      setTestResult({});
+      if (okTimerRef.current) { clearTimeout(okTimerRef.current); okTimerRef.current = undefined; }
+    }
+  }, [provider]);
+
+  // Cleanup ok timer
+  useEffect(() => () => { if (okTimerRef.current) clearTimeout(okTimerRef.current); }, []);
+
+  const handleTestKey = useCallback(async (providerName: 'anthropic' | 'openai') => {
+    const prov = data.ai.providers?.[providerName] ?? {} as ProviderConfig;
+    setTestResult(prev => ({ ...prev, [providerName]: { state: 'testing' } }));
+
+    try {
+      const body: Record<string, string> = { provider: providerName };
+      if (prov.apiKey) body.apiKey = prov.apiKey;
+      if (prov.model) body.model = prov.model;
+      if (providerName === 'openai' && prov.baseUrl) body.baseUrl = prov.baseUrl;
+
+      const res = await fetch('/api/settings/test-key', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      const json = await res.json();
+
+      if (json.ok) {
+        setTestResult(prev => ({ ...prev, [providerName]: { state: 'ok', latency: json.latency } }));
+        // Auto-clear after 5s
+        if (okTimerRef.current) clearTimeout(okTimerRef.current);
+        okTimerRef.current = setTimeout(() => {
+          setTestResult(prev => ({ ...prev, [providerName]: { state: 'idle' } }));
+        }, 5000);
+      } else {
+        setTestResult(prev => ({
+          ...prev,
+          [providerName]: { state: 'error', error: json.error, code: json.code },
+        }));
+      }
+    } catch {
+      setTestResult(prev => ({
+        ...prev,
+        [providerName]: { state: 'error', code: 'network_error', error: 'Network error' },
+      }));
+    }
+  }, [data.ai.providers]);
+
+  // Reset test result when key changes
+  const patchProviderWithReset = useCallback((name: 'anthropic' | 'openai', patch: Partial<ProviderConfig>) => {
+    if ('apiKey' in patch) {
+      setTestResult(prev => ({ ...prev, [name]: { state: 'idle' } }));
+    }
     updateAi({
       providers: {
         ...data.ai.providers,
         [name]: { ...data.ai.providers?.[name], ...patch },
       },
     });
+  }, [data.ai.providers, updateAi]);
+
+  function patchProvider(name: 'anthropic' | 'openai', patch: Partial<ProviderConfig>) {
+    patchProviderWithReset(name, patch);
   }
 
   const anthropic = data.ai.providers?.anthropic ?? { apiKey: '', model: '' };
@@ -31,6 +115,38 @@ export function AiTab({ data, updateAi, t }: AiTabProps) {
   const activeEnvKey = provider === 'anthropic' ? env.ANTHROPIC_API_KEY : env.OPENAI_API_KEY;
   const missingApiKey = !activeApiKey && !activeEnvKey;
 
+  // Test button helper
+  const renderTestButton = (providerName: 'anthropic' | 'openai', hasKey: boolean, hasEnv: boolean) => {
+    const result = testResult[providerName] ?? { state: 'idle' as TestState };
+    const disabled = result.state === 'testing' || (!hasKey && !hasEnv);
+
+    return (
+      <div className="flex items-center gap-2 mt-1.5">
+        <button
+          type="button"
+          disabled={disabled}
+          onClick={() => handleTestKey(providerName)}
+          className="inline-flex items-center gap-1.5 px-2.5 py-1 text-xs rounded-md border border-border text-muted-foreground hover:text-foreground hover:border-foreground/20 transition-colors disabled:opacity-40 disabled:cursor-not-allowed"
+        >
+          {result.state === 'testing' ? (
+            <>
+              <Loader2 size={12} className="animate-spin" />
+              {t.settings.ai.testKeyTesting}
+            </>
+          ) : (
+            t.settings.ai.testKey
+          )}
+        </button>
+        {result.state === 'ok' && result.latency != null && (
+          <span className="text-xs text-success">{t.settings.ai.testKeyOk(result.latency)}</span>
+        )}
+        {result.state === 'error' && (
+          <span className="text-xs text-error">✗ {errorMessage(t, result.code)}</span>
+        )}
+      </div>
+    );
+  };
+
   return (
     <div className="space-y-5">
       <Field label={<>{t.settings.ai.provider} <EnvBadge overridden={env.AI_PROVIDER} /></>}>
@@ -60,6 +176,7 @@ export function AiTab({ data, updateAi, t }: AiTabProps) {
               value={anthropic.apiKey}
               onChange={v => patchProvider('anthropic', { apiKey: v })}
             />
+            {renderTestButton('anthropic', !!anthropic.apiKey, !!env.ANTHROPIC_API_KEY)}
           </Field>
         </>
       ) : (
@@ -79,6 +196,7 @@ export function AiTab({ data, updateAi, t }: AiTabProps) {
               value={openai.apiKey}
               onChange={v => patchProvider('openai', { apiKey: v })}
             />
+            {renderTestButton('openai', !!openai.apiKey, !!env.OPENAI_API_KEY)}
           </Field>
           <Field
             label={<>{t.settings.ai.baseUrl} <EnvBadge overridden={env.OPENAI_BASE_URL} /></>}

package/app/components/setup/StepReview.tsx

@@ -7,7 +7,24 @@ import {
 import type { SetupState, SetupMessages, AgentInstallStatus } from './types';
 
 // ─── Restart Block ────────────────────────────────────────────────────────────
-function RestartBlock({ s, newPort }: { s: SetupMessages; newPort: number }) {
+
+/** Restart warning banner — shown in the content area */
+export function RestartBanner({ s }: { s: SetupMessages }) {
+  return (
+    <div className="space-y-2">
+      <div className="p-3 rounded-lg text-sm flex items-center gap-2"
+        style={{ background: 'color-mix(in srgb, var(--amber) 10%, transparent)', color: 'var(--amber)' }}>
+        <AlertTriangle size={14} /> {s.restartRequired}
+      </div>
+      <p className="text-xs" style={{ color: 'var(--muted-foreground)' }}>
+        {s.restartManual} <code className="font-mono">mindos start</code>
+      </p>
+    </div>
+  );
+}
+
+/** Restart button — shown in the bottom navigation bar (same position as Complete/Saving button) */
+export function RestartButton({ s, newPort }: { s: SetupMessages; newPort: number }) {
   const [restarting, setRestarting] = useState(false);
   const [done, setDone] = useState(false);
   const pollRef = useRef<ReturnType<typeof setInterval>>(undefined);
@@ -40,34 +57,23 @@ function RestartBlock({ s, newPort }: { s: SetupMessages; newPort: number }) {
 
   if (done) {
     return (
-      <div className="p-3 rounded-lg text-sm flex items-center gap-2"
-        style={{ background: 'color-mix(in srgb, var(--success) 10%, transparent)', color: 'var(--success)' }}>
+      <span className="flex items-center gap-1.5 px-5 py-2 text-sm font-medium rounded-lg"
+        style={{ background: 'color-mix(in srgb, var(--success) 15%, transparent)', color: 'var(--success)' }}>
         <CheckCircle2 size={14} /> {s.restartDone}
-      </div>
+      </span>
     );
   }
 
   return (
-    <div className="space-y-3">
-      <div className="p-3 rounded-lg text-sm flex items-center gap-2"
-        style={{ background: 'color-mix(in srgb, var(--amber) 10%, transparent)', color: 'var(--amber)' }}>
-        <AlertTriangle size={14} /> {s.restartRequired}
-      </div>
-      <div className="flex items-center gap-3">
-        <button
-          type="button"
-          onClick={handleRestart}
-          disabled={restarting}
-          className="flex items-center gap-1.5 px-4 py-2 text-sm rounded-lg transition-colors disabled:opacity-50"
-          style={{ background: 'var(--amber)', color: 'var(--amber-foreground)' }}>
-          {restarting ? <Loader2 size={13} className="animate-spin" /> : null}
-          {restarting ? s.restarting : s.restartNow}
-        </button>
-        <span className="text-xs" style={{ color: 'var(--muted-foreground)' }}>
-          {s.restartManual} <code className="font-mono">mindos start</code>
-        </span>
-      </div>
-    </div>
+    <button
+      type="button"
+      onClick={handleRestart}
+      disabled={restarting}
+      className="flex items-center gap-1.5 px-5 py-2 text-sm font-medium rounded-lg transition-colors disabled:opacity-50"
+      style={{ background: 'var(--amber)', color: 'var(--amber-foreground)' }}>
+      {restarting ? <Loader2 size={13} className="animate-spin" /> : null}
+      {restarting ? s.restarting : s.restartNow}
+    </button>
   );
 }
 
@@ -205,7 +211,7 @@ export default function StepReview({
           {s.completeFailed}: {error}
         </div>
       )}
-      {needsRestart && setupPhase === 'done' && <RestartBlock s={s} newPort={state.webPort} />}
+      {needsRestart && setupPhase === 'done' && <RestartBanner s={s} />}
     </div>
   );
 }

package/app/components/setup/index.tsx

@@ -11,6 +11,7 @@ import StepPorts from './StepPorts';
 import StepSecurity from './StepSecurity';
 import StepAgents from './StepAgents';
 import StepReview from './StepReview';
+import { RestartButton } from './StepReview';
 import StepDots from './StepDots';
 
 // ─── Helpers (shared by handleComplete + retryAgent) ─────────────────────────
@@ -439,14 +440,16 @@ export default function SetupWizard() {
               {s.next} <ChevronRight size={14} />
             </button>
           ) : completed ? (
-            // After completing: show Done link (no restart needed) or nothing (RestartBlock handles it)
-            !needsRestart ? (
+            // After completing: show Done link or Restart button in the same position
+            needsRestart ? (
+              <RestartButton s={s} newPort={state.webPort} />
+            ) : (
               <a href="/?welcome=1"
                 className="flex items-center gap-1 px-5 py-2 text-sm font-medium rounded-lg transition-colors"
                 style={{ background: 'var(--amber)', color: 'var(--amber-foreground)' }}>
                 {s.completeDone} &rarr;
               </a>
-            ) : null
+            )
           ) : (
             <button
               onClick={handleComplete}

package/app/instrumentation.ts

@@ -0,0 +1,19 @@
+export async function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { readFileSync } = await import('fs');
+    const { join, resolve } = await import('path');
+    const { homedir } = await import('os');
+    try {
+      const configPath = join(homedir(), '.mindos', 'config.json');
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      if (config.sync?.enabled && config.mindRoot) {
+        // Resolve absolute path to avoid Turbopack bundling issues
+        const syncModule = resolve(process.cwd(), '..', 'bin', 'lib', 'sync.js');
+        const { startSyncDaemon } = await import(/* webpackIgnore: true */ syncModule);
+        await startSyncDaemon(config.mindRoot);
+      }
+    } catch {
+      // Sync not configured or failed to start — silently skip
+    }
+  }
+}

package/app/lib/agent/prompt.ts

@@ -17,6 +17,38 @@ Tool policy:
 - Prefer targeted edits (update_section / insert_after_heading / append_to_file) over full overwrite.
 - Use write_file only when replacing the whole file is required.
 - INSTRUCTION.md is read-only and must not be modified.
+- Use append_csv for adding rows to CSV files instead of rewriting the whole file.
+- Use get_backlinks before renaming/moving/deleting to understand impact on other files.
+
+Destructive operations (use with caution):
+- delete_file: permanently removes a file — cannot be undone
+- move_file: changes file location — may break links in other files
+- write_file: overwrites entire file content — prefer partial edits
+Before executing destructive operations:
+- Before delete_file: list what links to this file (get_backlinks), warn user about impact
+- Before move_file: same — check backlinks first
+- Before write_file (full overwrite): confirm with user that full replacement is intended
+- NEVER chain multiple destructive operations without pausing to summarize what you've done
+
+File management tools:
+- rename_file: rename within same directory
+- move_file: move to a different path (reports affected backlinks)
+- get_backlinks: find all files that link to a given file
+
+Git history tools:
+- get_history: view commit log for a file
+- get_file_at_version: read file content at a past commit (use get_history first to find hashes)
+
+Complex task protocol:
+1. PLAN: For multi-step tasks, first output a numbered plan
+2. EXECUTE: Execute steps one by one, reporting progress
+3. VERIFY: After edits, re-read the file to confirm correctness
+4. SUMMARIZE: Conclude with a summary and suggest follow-up actions if relevant
+
+Step awareness:
+- You have a limited number of steps (configured by user, typically 10-30).
+- If a tool call fails or returns unexpected results, do NOT retry with the same arguments.
+- Try a different approach or ask the user for clarification.
 
 Uploaded files:
 - Users may upload local files (PDF, txt, csv, etc.) via the chat interface.