@geminilight/mindos 0.5.11 → 0.5.12

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/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/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.

package/app/lib/agent/stream-consumer.ts

@@ -0,0 +1,178 @@
+import type { Message, MessagePart, ToolCallPart, TextPart } from '@/lib/types';
+
+/**
+ * Parse a UIMessageStream SSE response into structured Message parts.
+ * The stream format is Server-Sent Events where each data line is a JSON-encoded UIMessageChunk.
+ */
+export async function consumeUIMessageStream(
+  body: ReadableStream<Uint8Array>,
+  onUpdate: (message: Message) => void,
+  signal?: AbortSignal,
+): Promise<Message> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  // Mutable working copies — we deep-clone when emitting to React
+  const parts: MessagePart[] = [];
+  const toolCalls = new Map<string, ToolCallPart>();
+  let currentTextId: string | null = null;
+
+  /** Deep-clone parts into an immutable Message snapshot for React state */
+  function buildMessage(): Message {
+    const clonedParts: MessagePart[] = parts.map(p => {
+      if (p.type === 'text') return { type: 'text' as const, text: p.text };
+      return { ...p }; // ToolCallPart — shallow copy is safe (all primitive fields + `input` is replaced, not mutated)
+    });
+    const textContent = clonedParts
+      .filter((p): p is TextPart => p.type === 'text')
+      .map(p => p.text)
+      .join('');
+    return {
+      role: 'assistant',
+      content: textContent,
+      parts: clonedParts,
+    };
+  }
+
+  function findOrCreateTextPart(id: string): TextPart {
+    if (currentTextId === id) {
+      const last = parts[parts.length - 1];
+      if (last && last.type === 'text') return last;
+    }
+    const part: TextPart = { type: 'text', text: '' };
+    parts.push(part);
+    currentTextId = id;
+    return part;
+  }
+
+  function findOrCreateToolCall(toolCallId: string, toolName?: string): ToolCallPart {
+    let tc = toolCalls.get(toolCallId);
+    if (!tc) {
+      tc = {
+        type: 'tool-call',
+        toolCallId,
+        toolName: toolName ?? 'unknown',
+        input: undefined,
+        state: 'pending',
+      };
+      toolCalls.set(toolCallId, tc);
+      parts.push(tc);
+      currentTextId = null; // break text continuity
+    }
+    return tc;
+  }
+
+  try {
+    while (true) {
+      if (signal?.aborted) break;
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      // Process complete SSE lines
+      const lines = buffer.split('\n');
+      buffer = lines.pop() ?? ''; // keep incomplete last line
+
+      let changed = false;
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+
+        // SSE format: the ai SDK v6 UIMessageStream uses "d:{json}\n"
+        // Also handle standard "data:{json}" for robustness
+        let jsonStr: string | null = null;
+        if (trimmed.startsWith('d:')) {
+          jsonStr = trimmed.slice(2);
+        } else if (trimmed.startsWith('data:')) {
+          jsonStr = trimmed.slice(5).trim();
+        }
+
+        if (!jsonStr) continue;
+
+        let chunk: Record<string, unknown>;
+        try {
+          chunk = JSON.parse(jsonStr);
+        } catch {
+          continue; // skip malformed lines
+        }
+
+        const type = chunk.type as string;
+
+        switch (type) {
+          case 'text-start': {
+            findOrCreateTextPart(chunk.id as string);
+            changed = true;
+            break;
+          }
+          case 'text-delta': {
+            const part = findOrCreateTextPart(chunk.id as string);
+            part.text += chunk.delta as string;
+            changed = true;
+            break;
+          }
+          case 'text-end': {
+            // Text part is complete — no state change needed
+            break;
+          }
+          case 'tool-input-start': {
+            const tc = findOrCreateToolCall(chunk.toolCallId as string, chunk.toolName as string);
+            tc.state = 'running';
+            changed = true;
+            break;
+          }
+          case 'tool-input-delta': {
+            // Streaming input — we wait for input-available for the complete input
+            break;
+          }
+          case 'tool-input-available': {
+            const tc = findOrCreateToolCall(chunk.toolCallId as string, chunk.toolName as string);
+            tc.input = chunk.input;
+            tc.state = 'running';
+            changed = true;
+            break;
+          }
+          case 'tool-output-available': {
+            const tc = toolCalls.get(chunk.toolCallId as string);
+            if (tc) {
+              tc.output = typeof chunk.output === 'string' ? chunk.output : JSON.stringify(chunk.output);
+              tc.state = 'done';
+              changed = true;
+            }
+            break;
+          }
+          case 'tool-output-error':
+          case 'tool-input-error': {
+            const tc = toolCalls.get(chunk.toolCallId as string);
+            if (tc) {
+              tc.output = (chunk.errorText as string) ?? 'Error';
+              tc.state = 'error';
+              changed = true;
+            }
+            break;
+          }
+          case 'error': {
+            const errorText = (chunk.errorText as string) ?? 'Unknown error';
+            parts.push({ type: 'text', text: `\n\n**Error:** ${errorText}` });
+            currentTextId = null;
+            changed = true;
+            break;
+          }
+          // step-start, reasoning-*, metadata, finish — ignored for now
+          default:
+            break;
+        }
+      }
+
+      // Emit once per reader.read() batch, not per SSE line
+      if (changed) {
+        onUpdate(buildMessage());
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+
+  return buildMessage();
+}

package/app/lib/agent/tools.ts

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import {
   searchFiles, getFileContent, getFileTree, getRecentlyModified,
   saveFileContent, createFile, appendToFile, insertAfterHeading, updateSection,
+  deleteFile, renameFile, moveFile, findBacklinks, gitLog, gitShowFile, appendCsvRow,
 } from '@/lib/fs';
 import { assertNotProtected } from '@/lib/core';
 import { logAgentOp } from './log';
@@ -169,4 +170,125 @@ export const knowledgeBaseTools = {
       }
     }),
   }),
+
+  // ─── New tools (Phase 1a) ──────────────────────────────────────────────────
+
+  delete_file: tool({
+    description: 'Permanently delete a file from the knowledge base. This is destructive and cannot be undone.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path to delete'),
+    }),
+    execute: logged('delete_file', async ({ path }) => {
+      try {
+        assertWritable(path);
+        deleteFile(path);
+        return `File deleted: ${path}`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  rename_file: tool({
+    description: 'Rename a file within its current directory. Only the filename changes, not the directory.',
+    inputSchema: z.object({
+      path: z.string().describe('Current relative file path'),
+      new_name: z.string().describe('New filename (no path separators, e.g. "new-name.md")'),
+    }),
+    execute: logged('rename_file', async ({ path, new_name }) => {
+      try {
+        assertWritable(path);
+        const newPath = renameFile(path, new_name);
+        return `File renamed: ${path} → ${newPath}`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  move_file: tool({
+    description: 'Move a file to a new location. Also returns any files that had backlinks affected by the move.',
+    inputSchema: z.object({
+      from_path: z.string().describe('Current relative file path'),
+      to_path: z.string().describe('New relative file path'),
+    }),
+    execute: logged('move_file', async ({ from_path, to_path }) => {
+      try {
+        assertWritable(from_path);
+        const result = moveFile(from_path, to_path);
+        const affected = result.affectedFiles.length > 0
+          ? `\nAffected backlinks in: ${result.affectedFiles.join(', ')}`
+          : '';
+        return `File moved: ${from_path} → ${result.newPath}${affected}`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  get_backlinks: tool({
+    description: 'Find all files that reference a given file path. Useful for understanding connections between notes.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path to find backlinks for'),
+    }),
+    execute: logged('get_backlinks', async ({ path }) => {
+      try {
+        const backlinks = findBacklinks(path);
+        if (backlinks.length === 0) return `No backlinks found for: ${path}`;
+        return backlinks.map(b => `- **${b.source}** (L${b.line}): ${b.context}`).join('\n');
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  get_history: tool({
+    description: 'Get git commit history for a file. Shows recent commits that modified this file.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path'),
+      limit: z.number().min(1).max(50).default(10).describe('Number of commits to return'),
+    }),
+    execute: logged('get_history', async ({ path, limit }) => {
+      try {
+        const commits = gitLog(path, limit);
+        if (commits.length === 0) return `No git history found for: ${path}`;
+        return commits.map(c => `- \`${c.hash.slice(0, 7)}\` ${c.date} — ${c.message} (${c.author})`).join('\n');
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  get_file_at_version: tool({
+    description: 'Read the content of a file at a specific git commit. Use get_history first to find commit hashes.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative file path'),
+      commit: z.string().describe('Git commit hash (full or abbreviated)'),
+    }),
+    execute: logged('get_file_at_version', async ({ path, commit }) => {
+      try {
+        const content = gitShowFile(path, commit);
+        return truncate(content);
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
+
+  append_csv: tool({
+    description: 'Append a row to a CSV file. Values are automatically escaped per RFC 4180.',
+    inputSchema: z.object({
+      path: z.string().describe('Relative path to .csv file'),
+      row: z.array(z.string()).describe('Array of cell values for the new row'),
+    }),
+    execute: logged('append_csv', async ({ path, row }) => {
+      try {
+        assertWritable(path);
+        const result = appendCsvRow(path, row);
+        return `Row appended to ${path} (now ${result.newRowCount} rows)`;
+      } catch (e: unknown) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+      }
+    }),
+  }),
 };

package/app/lib/types.ts

@@ -13,9 +13,27 @@ export interface BacklinkItem {
   snippets: string[];
 }
 
+export interface ToolCallPart {
+  type: 'tool-call';
+  toolCallId: string;
+  toolName: string;
+  input: unknown;
+  output?: string;
+  state: 'pending' | 'running' | 'done' | 'error';
+}
+
+export interface TextPart {
+  type: 'text';
+  text: string;
+}
+
+export type MessagePart = TextPart | ToolCallPart;
+
 export interface Message {
   role: 'user' | 'assistant';
   content: string;
+  /** Structured parts for assistant messages (tool calls + text segments) */
+  parts?: MessagePart[];
 }
 
 export interface LocalAttachment {

package/app/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/app/package.json

@@ -3,10 +3,10 @@
   "version": "0.1.0",
   "private": true,
   "scripts": {
-    "dev": "next dev -p ${MINDOS_WEB_PORT:-3000}",
+    "dev": "next dev -p ${MINDOS_WEB_PORT:-3456}",
     "prebuild": "node ../scripts/gen-renderer-index.js",
     "build": "next build",
-    "start": "next start -p ${MINDOS_WEB_PORT:-3000}",
+    "start": "next start -p ${MINDOS_WEB_PORT:-3456}",
     "lint": "eslint",
     "test": "vitest run"
   },