@geminilight/mindos 0.6.29 → 0.6.31

package/app/lib/actions.ts

@@ -3,6 +3,7 @@
 import fs from 'fs';
 import path from 'path';
 import { createFile, deleteFile, deleteDirectory, convertToSpace, renameFile, renameSpace, getMindRoot, invalidateCache, collectAllFiles } from '@/lib/fs';
+import { moveToTrash, restoreFromTrash, restoreAsCopy, permanentlyDelete, listTrash, emptyTrash, purgeExpired, type TrashMeta } from '@/lib/core/trash';
 import { createSpaceFilesystem, generateReadmeTemplate } from '@/lib/core/create-space';
 import { INSTRUCTION_TEMPLATE, cleanDirName } from '@/lib/core/space-scaffold';
 import { revalidatePath } from 'next/cache';
@@ -25,7 +26,8 @@ export async function createFileAction(dirPath: string, fileName: string): Promi
 
 export async function deleteFileAction(filePath: string): Promise<{ success: boolean; error?: string }> {
   try {
-    deleteFile(filePath);
+    moveToTrash(getMindRoot(), filePath);
+    invalidateCache();
     revalidatePath('/', 'layout');
     return { success: true };
   } catch (err) {
@@ -59,7 +61,8 @@ export async function deleteFolderAction(
   dirPath: string,
 ): Promise<{ success: boolean; error?: string }> {
   try {
-    deleteDirectory(dirPath);
+    moveToTrash(getMindRoot(), dirPath);
+    invalidateCache();
     revalidatePath('/', 'layout');
     return { success: true };
   } catch (err) {
@@ -84,7 +87,8 @@ export async function deleteSpaceAction(
   spacePath: string,
 ): Promise<{ success: boolean; error?: string }> {
   try {
-    deleteDirectory(spacePath);
+    moveToTrash(getMindRoot(), spacePath);
+    invalidateCache();
     revalidatePath('/', 'layout');
     return { success: true };
   } catch (err) {
@@ -189,3 +193,53 @@ export async function cleanupExamplesAction(): Promise<{ success: boolean; delet
     return { success: false, deleted: 0, error: err instanceof Error ? err.message : 'Failed to cleanup' };
   }
 }
+
+// ─── Trash Actions ────────────────────────────────────────────────────────────
+
+export async function listTrashAction(): Promise<TrashMeta[]> {
+  // Purge expired items on each list call (lazy cleanup)
+  purgeExpired(getMindRoot());
+  return listTrash(getMindRoot());
+}
+
+export async function restoreFromTrashAction(
+  trashId: string,
+  mode: 'restore' | 'overwrite' | 'copy' = 'restore',
+): Promise<{ success: boolean; restoredPath?: string; error?: string; conflict?: boolean }> {
+  try {
+    const root = getMindRoot();
+    let result: { restoredPath: string };
+    if (mode === 'copy') {
+      result = restoreAsCopy(root, trashId);
+    } else {
+      result = restoreFromTrash(root, trashId, mode === 'overwrite');
+    }
+    invalidateCache();
+    revalidatePath('/', 'layout');
+    return { success: true, restoredPath: result.restoredPath };
+  } catch (err: unknown) {
+    const e = err as Error & { code?: string };
+    if (e.code === 'RESTORE_CONFLICT') {
+      return { success: false, error: e.message, conflict: true };
+    }
+    return { success: false, error: e.message ?? 'Failed to restore' };
+  }
+}
+
+export async function permanentlyDeleteAction(trashId: string): Promise<{ success: boolean; error?: string }> {
+  try {
+    permanentlyDelete(getMindRoot(), trashId);
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to delete' };
+  }
+}
+
+export async function emptyTrashAction(): Promise<{ success: boolean; count?: number; error?: string }> {
+  try {
+    const count = emptyTrash(getMindRoot());
+    return { success: true, count };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to empty trash' };
+  }
+}

package/app/lib/agent/model.ts

@@ -1,6 +1,19 @@
 import { getModel as piGetModel, type Model } from '@mariozechner/pi-ai';
 import { effectiveAiConfig } from '@/lib/settings';
 
+/** Check if any message in the conversation contains images */
+export function hasImages(messages: Array<{ images?: unknown[] }>): boolean {
+  return messages.some(m => m.images && m.images.length > 0);
+}
+
+/** Ensure model input includes 'image' when images are present */
+function ensureVisionCapable(model: Model<any>): Model<any> {
+  const inputs = model.input as readonly string[];
+  if (inputs.includes('image')) return model;
+  // Upgrade input to include image — most modern models support it
+  return { ...model, input: [...inputs, 'image'] as any };
+}
+
 /**
  * Build a pi-ai Model for the configured provider.
  *
@@ -11,7 +24,7 @@ import { effectiveAiConfig } from '@/lib/settings';
  *
  * Returns { model, modelName, apiKey } — Agent needs model + apiKey via getApiKey hook.
  */
-export function getModelConfig(): {
+export function getModelConfig(options?: { hasImages?: boolean }): {
   model: Model<any>;
   modelName: string;
   apiKey: string;
@@ -77,7 +90,8 @@ export function getModelConfig(): {
       }
     }
 
-    return { model, modelName, apiKey: cfg.openaiApiKey, provider: 'openai' };
+    const finalModel = options?.hasImages ? ensureVisionCapable(model) : model;
+    return { model: finalModel, modelName, apiKey: cfg.openaiApiKey, provider: 'openai' };
   }
 
   // Anthropic
@@ -104,5 +118,6 @@ export function getModelConfig(): {
     };
   }
 
-  return { model, modelName, apiKey: cfg.anthropicApiKey, provider: 'anthropic' };
+  const finalModel = options?.hasImages ? ensureVisionCapable(model) : model;
+  return { model: finalModel, modelName, apiKey: cfg.anthropicApiKey, provider: 'anthropic' };
 }

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

@@ -16,6 +16,20 @@
  */
 import type { Message, MessagePart, ToolCallPart, TextPart, ReasoningPart } from '@/lib/types';
 
+/** Tools that modify files — trigger files-changed notification on completion */
+const FILE_MUTATING_TOOLS = new Set([
+  'write_file', 'create_file', 'batch_create_files',
+  'update_section', 'insert_after_heading', 'delete_file',
+  'rename_file', 'create_space',
+]);
+
+/** Notify the app that files were changed by the AI agent */
+function notifyFilesChanged() {
+  if (typeof window !== 'undefined') {
+    window.dispatchEvent(new Event('mindos:files-changed'));
+  }
+}
+
 export async function consumeUIMessageStream(
   body: ReadableStream<Uint8Array>,
   onUpdate: (message: Message) => void,
@@ -158,6 +172,10 @@ export async function consumeUIMessageStream(
               tc.output = output ?? '';
               tc.state = (event.isError ? 'error' : 'done');
               changed = true;
+              // Notify when a file-modifying tool completes successfully
+              if (!event.isError && FILE_MUTATING_TOOLS.has(tc.toolName)) {
+                notifyFilesChanged();
+              }
             }
             break;
           }

package/app/lib/agent/to-agent-messages.ts

@@ -13,13 +13,36 @@
  * - Orphaned tool calls (running/pending from interrupted streams): supply empty result
  * - Reasoning parts: filtered out (display-only, not sent back to LLM)
  */
-import type { Message as FrontendMessage, ToolCallPart as FrontendToolCallPart } from '@/lib/types';
+import type { Message as FrontendMessage, ToolCallPart as FrontendToolCallPart, ImagePart } from '@/lib/types';
 import type { AgentMessage } from '@mariozechner/pi-agent-core';
 import type { UserMessage, AssistantMessage, ToolResultMessage } from '@mariozechner/pi-ai';
 
 // Re-export for convenience
 export type { AgentMessage } from '@mariozechner/pi-agent-core';
 
+/** Build multimodal content array for user messages with images */
+function buildUserContent(text: string, images?: ImagePart[]): string | any[] {
+  // Filter out stripped images (empty data from persisted sessions)
+  const validImages = images?.filter(img => img.data);
+  if (!validImages || validImages.length === 0) return text;
+
+  // Multimodal content: images first, then text
+  // Use pi-ai ImageContent format: { type: 'image', data: base64, mimeType }
+  // The SDK converts this to the provider-specific format (Anthropic/OpenAI) internally
+  const parts: any[] = [];
+  for (const img of validImages) {
+    parts.push({
+      type: 'image',
+      data: img.data,
+      mimeType: img.mimeType,
+    });
+  }
+  if (text) {
+    parts.push({ type: 'text', text });
+  }
+  return parts;
+}
+
 export function toAgentMessages(messages: FrontendMessage[]): AgentMessage[] {
   const result: AgentMessage[] = [];
 
@@ -29,7 +52,7 @@ export function toAgentMessages(messages: FrontendMessage[]): AgentMessage[] {
     if (msg.role === 'user') {
       result.push({
         role: 'user',
-        content: msg.content,
+        content: buildUserContent(msg.content, msg.images),
         timestamp,
       } satisfies UserMessage as AgentMessage);
       continue;

package/app/lib/agent/tools.ts

@@ -11,6 +11,7 @@ import { readSkillContentByName, scanSkillDirs } from '@/lib/pi-integration/skil
 import { callMcporterTool, createMcporterAgentTools, listMcporterServers, listMcporterTools } from '@/lib/pi-integration/mcporter';
 import { a2aTools } from '@/lib/a2a/a2a-tools';
 import { acpTools } from '@/lib/acp/acp-tools';
+import { buildLineDiff, collapseDiffContext } from '@/components/changes/line-diff';
 
 // Max chars per file to avoid token overflow (~100k chars ≈ ~25k tokens)
 const MAX_FILE_CHARS = 20_000;
@@ -39,6 +40,38 @@ function textResult(text: string): AgentToolResult<Record<string, never>> {
   return { content: [{ type: 'text', text }], details: {} as Record<string, never> };
 }
 
+/** Build a compact diff summary for tool output. Max 30 diff lines to avoid bloating agent context. */
+function buildDiffSummary(before: string, after: string): string {
+  if (before === after) return '';
+  // Skip diff for very large files — LCS is O(n*m), would block agent
+  const beforeLines = before.split('\n').length;
+  const afterLines = after.split('\n').length;
+  if (beforeLines > 2000 || afterLines > 2000) {
+    const added = Math.max(0, afterLines - beforeLines);
+    const removed = Math.max(0, beforeLines - afterLines);
+    return `(~+${added} ~−${removed}, ${afterLines} lines total)\n\n--- changes ---\n  (diff skipped — file too large)`;
+  }
+  const raw = buildLineDiff(before, after);
+  const inserts = raw.filter(r => r.type === 'insert').length;
+  const deletes = raw.filter(r => r.type === 'delete').length;
+  const stats = `+${inserts} −${deletes}`;
+  const collapsed = collapseDiffContext(raw, 2);
+  const MAX_DIFF_LINES = 30;
+  const lines: string[] = [];
+  for (const row of collapsed) {
+    if (lines.length >= MAX_DIFF_LINES) { lines.push('... (diff truncated)'); break; }
+    if (row.type === 'gap') { lines.push(`  ... ${row.count} lines unchanged ...`); continue; }
+    const prefix = row.type === 'insert' ? '+' : row.type === 'delete' ? '-' : ' ';
+    lines.push(`${prefix} ${row.text}`);
+  }
+  return `(${stats})\n\n--- changes ---\n${lines.join('\n')}`;
+}
+
+/** Safe read — returns empty string if file doesn't exist */
+function safeReadContent(filePath: string): string {
+  try { return getFileContent(filePath); } catch { return ''; }
+}
+
 /** Safe execute wrapper — catches all errors, returns error text (never throws) */
 function safeExecute<T>(
   fn: (toolCallId: string, params: T, signal?: AbortSignal) => Promise<AgentToolResult<any>>,
@@ -527,8 +560,10 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     description: 'Overwrite the entire content of an existing file. Use read_file first to see current content. Prefer update_section or insert_after_heading for partial edits.',
     parameters: WriteFileParams,
     execute: safeExecute(async (_id, params: Static<typeof WriteFileParams>) => {
+      const before = safeReadContent(params.path);
       saveFileContent(params.path, params.content);
-      return textResult(`File written: ${params.path}`);
+      const diff = buildDiffSummary(before, params.content);
+      return textResult(`File written: ${params.path}${diff ? ' ' + diff : ''}`);
     }),
   },
 
@@ -538,8 +573,10 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     description: 'Create a new file. Only .md and .csv files are allowed. Parent directories are created automatically. Does NOT create Space scaffolding (INSTRUCTION.md/README.md). Use create_space to create a Space.',
     parameters: CreateFileParams,
     execute: safeExecute(async (_id, params: Static<typeof CreateFileParams>) => {
-      createFile(params.path, params.content ?? '');
-      return textResult(`File created: ${params.path}`);
+      const content = params.content ?? '';
+      createFile(params.path, content);
+      const lineCount = content.split('\n').length;
+      return textResult(`File created: ${params.path} (+${lineCount})\n\n--- changes ---\n${content.split('\n').slice(0, 30).map(l => '+ ' + l).join('\n')}${lineCount > 30 ? '\n... (truncated)' : ''}`);
     }),
   },
 
@@ -571,8 +608,11 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     description: 'Append text to the end of an existing file. A blank line separator is added automatically.',
     parameters: AppendParams,
     execute: safeExecute(async (_id, params: Static<typeof AppendParams>) => {
+      const before = safeReadContent(params.path);
       appendToFile(params.path, params.content);
-      return textResult(`Content appended to: ${params.path}`);
+      const after = safeReadContent(params.path);
+      const diff = buildDiffSummary(before, after);
+      return textResult(`Content appended to: ${params.path}${diff ? ' ' + diff : ''}`);
     }),
   },
 
@@ -582,8 +622,11 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     description: 'Insert content right after a Markdown heading. Useful for adding items under a specific section. If heading matches fail, use edit_lines instead.',
     parameters: InsertHeadingParams,
     execute: safeExecute(async (_id, params: Static<typeof InsertHeadingParams>) => {
+      const before = safeReadContent(params.path);
       insertAfterHeading(params.path, params.heading, params.content);
-      return textResult(`Content inserted after heading "${params.heading}" in ${params.path}`);
+      const after = safeReadContent(params.path);
+      const diff = buildDiffSummary(before, after);
+      return textResult(`Content inserted after heading "${params.heading}" in ${params.path}${diff ? ' ' + diff : ''}`);
     }),
   },
 
@@ -593,8 +636,11 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     description: 'Replace the content of a Markdown section identified by its heading. The section spans from the heading to the next heading of equal or higher level. If heading matches fail, use edit_lines instead.',
     parameters: UpdateSectionParams,
     execute: safeExecute(async (_id, params: Static<typeof UpdateSectionParams>) => {
+      const before = safeReadContent(params.path);
       updateSection(params.path, params.heading, params.content);
-      return textResult(`Section "${params.heading}" updated in ${params.path}`);
+      const after = safeReadContent(params.path);
+      const diff = buildDiffSummary(before, after);
+      return textResult(`Section "${params.heading}" updated in ${params.path}${diff ? ' ' + diff : ''}`);
     }),
   },
 
@@ -607,12 +653,13 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
       const { path: fp, start_line, end_line, content } = params;
       const start = Math.max(0, start_line - 1);
       const end = Math.max(0, end_line - 1);
-      
+      const before = safeReadContent(fp);
       const mindRoot = getMindRoot();
-      // Import the core function dynamically or it should be added to lib/fs.ts
       const { updateLines } = await import('@/lib/core');
       updateLines(mindRoot, fp, start, end, content.split('\n'));
-      return textResult(`Lines ${start_line}-${end_line} replaced in ${fp}`);
+      const after = safeReadContent(fp);
+      const diff = buildDiffSummary(before, after);
+      return textResult(`Lines ${start_line}-${end_line} replaced in ${fp}${diff ? ' ' + diff : ''}`);
     }),
   },
 

package/app/lib/core/export.ts

@@ -0,0 +1,116 @@
+import fs from 'fs';
+import path from 'path';
+import { remark } from 'remark';
+import remarkGfm from 'remark-gfm';
+import remarkHtml from 'remark-html';
+
+/** Convert wiki-links [[target]] → relative HTML links */
+export function convertWikiLinks(content: string, _currentPath: string): string {
+  return content.replace(/\[\[([^\]|]+?)(?:\|([^\]]+?))?\]\]/g, (_match, target: string, display?: string) => {
+    const label = display ?? target;
+    const href = target.replace(/\s+/g, '%20');
+    return `<a href="${href}.html">${label}</a>`;
+  });
+}
+
+/** Convert markdown to a complete standalone HTML document */
+export async function markdownToHTML(content: string, title: string, currentPath = ''): Promise<string> {
+  // Convert wiki-links first
+  const processed = convertWikiLinks(content, currentPath);
+
+  const result = await remark()
+    .use(remarkGfm)
+    .use(remarkHtml, { sanitize: false })
+    .process(processed);
+
+  const body = String(result);
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(title)}</title>
+  <style>
+    :root { color-scheme: light dark; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      max-width: 720px;
+      margin: 2rem auto;
+      padding: 0 1.5rem;
+      line-height: 1.7;
+      color: #1a1a1a;
+      background: #fff;
+    }
+    @media (prefers-color-scheme: dark) {
+      body { color: #e0e0e0; background: #1a1a1a; }
+      a { color: #6eb5ff; }
+      code { background: #2a2a2a; }
+      pre { background: #2a2a2a; }
+      blockquote { border-color: #444; }
+      table, th, td { border-color: #444; }
+    }
+    h1 { font-size: 1.8rem; font-weight: 700; margin: 2rem 0 1rem; border-bottom: 1px solid #eee; padding-bottom: 0.3rem; }
+    h2 { font-size: 1.4rem; font-weight: 600; margin: 1.5rem 0 0.8rem; }
+    h3 { font-size: 1.15rem; font-weight: 600; margin: 1.2rem 0 0.5rem; }
+    a { color: #0066cc; text-decoration: none; }
+    a:hover { text-decoration: underline; }
+    code { font-family: 'SF Mono', Menlo, monospace; font-size: 0.875em; background: #f5f5f5; padding: 0.15em 0.4em; border-radius: 3px; }
+    pre { background: #f5f5f5; padding: 1rem; border-radius: 6px; overflow-x: auto; }
+    pre code { background: none; padding: 0; }
+    blockquote { margin: 1rem 0; padding: 0.5rem 1rem; border-left: 3px solid #ddd; color: #666; }
+    table { border-collapse: collapse; width: 100%; margin: 1rem 0; }
+    th, td { border: 1px solid #ddd; padding: 0.5rem 0.75rem; text-align: left; }
+    th { background: #f8f8f8; font-weight: 600; }
+    img { max-width: 100%; height: auto; border-radius: 4px; }
+    hr { border: none; border-top: 1px solid #eee; margin: 2rem 0; }
+    ul, ol { padding-left: 1.5rem; }
+    li { margin: 0.25rem 0; }
+    .task-list-item { list-style: none; margin-left: -1.5rem; }
+    .task-list-item input { margin-right: 0.5rem; }
+    @media print {
+      body { max-width: 100%; margin: 0; padding: 1rem; }
+      a { color: inherit; text-decoration: underline; }
+    }
+  </style>
+</head>
+<body>
+${body}
+<footer style="margin-top:3rem;padding-top:1rem;border-top:1px solid #eee;font-size:0.75rem;color:#999;">
+  Exported from MindOS
+</footer>
+</body>
+</html>`;
+}
+
+function escapeHtml(str: string): string {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+/** Collect all exportable files in a directory tree */
+export function collectExportFiles(mindRoot: string, dirPath: string): { relativePath: string; content: string }[] {
+  const fullDir = path.join(mindRoot, dirPath);
+  if (!fs.existsSync(fullDir) || !fs.statSync(fullDir).isDirectory()) return [];
+
+  const results: { relativePath: string; content: string }[] = [];
+  const SKIP = new Set(['INSTRUCTION.md', '.DS_Store']);
+
+  function walk(dir: string, prefix: string) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') || SKIP.has(entry.name)) continue;
+      const fullPath = path.join(dir, entry.name);
+      const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(fullPath, relPath);
+      } else if (entry.name.endsWith('.md') || entry.name.endsWith('.csv')) {
+        try {
+          results.push({ relativePath: relPath, content: fs.readFileSync(fullPath, 'utf-8') });
+        } catch { /* skip unreadable */ }
+      }
+    }
+  }
+
+  walk(fullDir, '');
+  return results;
+}