@geminilight/mindos 0.5.68 → 0.5.70

package/app/lib/agent/tools.ts

@@ -12,7 +12,14 @@ const MAX_FILE_CHARS = 20_000;
 
 export function truncate(content: string): string {
   if (content.length <= MAX_FILE_CHARS) return content;
-  return content.slice(0, MAX_FILE_CHARS) + `\n\n[...truncated — file is ${content.length} chars, showing first ${MAX_FILE_CHARS}]`;
+  
+  // Smart truncation: try to truncate at a natural boundary (newline)
+  let cutoff = content.lastIndexOf('\n', MAX_FILE_CHARS);
+  if (cutoff === -1) cutoff = MAX_FILE_CHARS;
+  
+  const totalLines = content.split('\n').length;
+  
+  return content.slice(0, cutoff) + `\n\n[...truncated — file is ${content.length} chars (${totalLines} lines), showing first ~${cutoff} chars]\n[Use the read_file_chunk tool to read the rest of the file by specifying start_line and end_line]`;
 }
 
 // ─── Helper: format tool error consistently ────────────────────────────────
@@ -51,6 +58,12 @@ const PathParam = Type.Object({
   path: Type.String({ description: 'Relative file path' }),
 });
 
+const ReadFileChunkParams = Type.Object({
+  path: Type.String({ description: 'Relative file path' }),
+  start_line: Type.Number({ description: 'Line number to start reading from (1-indexed)' }),
+  end_line: Type.Number({ description: 'Line number to stop reading at (1-indexed)' }),
+});
+
 const QueryParam = Type.Object({
   query: Type.String({ description: 'Search query (case-insensitive)' }),
 });
@@ -69,11 +82,26 @@ const CreateFileParams = Type.Object({
   content: Type.Optional(Type.String({ description: 'Initial file content' })),
 });
 
+const BatchCreateFileParams = Type.Object({
+  files: Type.Array(Type.Object({
+    path: Type.String({ description: 'Relative file path (must end in .md or .csv)' }),
+    content: Type.String({ description: 'Initial file content' }),
+  }), { description: 'List of files to create' }),
+});
+
 const AppendParams = Type.Object({
   path: Type.String({ description: 'Relative file path' }),
   content: Type.String({ description: 'Content to append' }),
 });
 
+const FetchUrlParams = Type.Object({
+  url: Type.String({ description: 'The HTTP/HTTPS URL to fetch' }),
+});
+
+const WebSearchParams = Type.Object({
+  query: Type.String({ description: 'The search query or keywords to look up on the internet' }),
+});
+
 const InsertHeadingParams = Type.Object({
   path: Type.String({ description: 'Relative file path' }),
   heading: Type.String({ description: 'Heading text to find (e.g. "## Tasks" or just "Tasks")' }),
@@ -86,6 +114,13 @@ const UpdateSectionParams = Type.Object({
   content: Type.String({ description: 'New content for the section' }),
 });
 
+const EditLinesParams = Type.Object({
+  path: Type.String({ description: 'Relative file path' }),
+  start_line: Type.Number({ description: '1-indexed line number to start replacing' }),
+  end_line: Type.Number({ description: '1-indexed line number to stop replacing (inclusive)' }),
+  content: Type.String({ description: 'New content to insert in place of those lines' }),
+});
+
 const RenameParams = Type.Object({
   path: Type.String({ description: 'Current relative file path' }),
   new_name: Type.String({ description: 'New filename (no path separators, e.g. "new-name.md")' }),
@@ -115,8 +150,8 @@ const CsvAppendParams = Type.Object({
 
 // Write-operation tool names — used by beforeToolCall for write-protection
 export const WRITE_TOOLS = new Set([
-  'write_file', 'create_file', 'append_to_file', 'insert_after_heading',
-  'update_section', 'delete_file', 'rename_file', 'move_file', 'append_csv',
+  'write_file', 'create_file', 'batch_create_files', 'append_to_file', 'insert_after_heading',
+  'update_section', 'edit_lines', 'delete_file', 'rename_file', 'move_file', 'append_csv',
 ]);
 
 export const knowledgeBaseTools: AgentTool<any>[] = [
@@ -171,13 +206,39 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
   {
     name: 'read_file',
     label: 'Read File',
-    description: 'Read the content of a file by its relative path. Always read a file before modifying it.',
+    description: 'Read the content of a file by its relative path. Always read a file before modifying it. If the file is too large, it will be truncated. Use read_file_chunk to read specific parts of large files.',
     parameters: PathParam,
     execute: safeExecute(async (_id, params: Static<typeof PathParam>) => {
       return textResult(truncate(getFileContent(params.path)));
     }),
   },
 
+  {
+    name: 'read_file_chunk',
+    label: 'Read File Chunk',
+    description: 'Read a specific range of lines from a file. Highly recommended for reading large files that were truncated by read_file.',
+    parameters: ReadFileChunkParams,
+    execute: safeExecute(async (_id, params: Static<typeof ReadFileChunkParams>) => {
+      const content = getFileContent(params.path);
+      const lines = content.split('\n');
+      const start = Math.max(1, params.start_line);
+      const end = Math.min(lines.length, params.end_line);
+      
+      if (start > end) {
+        return textResult(`Error: start_line (${start}) is greater than end_line (${end}) or file has fewer lines.`);
+      }
+      
+      // Prefix each line with its line number (1-indexed)
+      const pad = String(lines.length).length;
+      const chunk = lines
+        .slice(start - 1, end)
+        .map((l, i) => `${String(start + i).padStart(pad, ' ')} | ${l}`)
+        .join('\n');
+        
+      return textResult(`Showing lines ${start} to ${end} of ${lines.length}:\n\n${chunk}`);
+    }),
+  },
+
   {
     name: 'search',
     label: 'Search',
@@ -190,6 +251,144 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     }),
   },
 
+  {
+    name: 'web_search',
+    label: 'Web Search',
+    description: 'Search the internet for up-to-date information. Uses DuckDuckGo HTML search. Returns top search results with titles, snippets, and URLs.',
+    parameters: WebSearchParams,
+    execute: safeExecute(async (_id, params: Static<typeof WebSearchParams>) => {
+      try {
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(params.query)}`;
+        const res = await fetch(url, {
+          headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Accept-Language': 'en-US,en;q=0.9',
+          },
+          signal: AbortSignal.timeout(10000)
+        });
+        
+        if (!res.ok) {
+          return textResult(`Failed to search: HTTP ${res.status}`);
+        }
+        
+        const html = await res.text();
+        const results: string[] = [];
+        
+        // Simple regex parsing for DuckDuckGo HTML results
+        const resultBlocks = html.split('class="result__body"').slice(1);
+        
+        for (let i = 0; i < Math.min(resultBlocks.length, 5); i++) {
+          const block = resultBlocks[i];
+          
+          const titleMatch = block.match(/class="result__title"[^>]*>[\s\S]*?<a[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i);
+          const snippetMatch = block.match(/class="result__snippet[^>]*>([\s\S]*?)(?:<\/a>|<\/div>)/i);
+          
+          if (titleMatch) {
+            let link = titleMatch[1];
+            // Decode DuckDuckGo redirect URL if necessary
+            if (link.startsWith('//duckduckgo.com/l/?uddg=')) {
+              const urlParam = new URL('https:' + link).searchParams.get('uddg');
+              if (urlParam) link = decodeURIComponent(urlParam);
+            }
+            
+            // Clean up tags
+            const title = titleMatch[2].replace(/<[^>]+>/g, '').trim();
+            const snippet = snippetMatch ? snippetMatch[1].replace(/<[^>]+>/g, '').trim() : '';
+            
+            results.push(`### ${i+1}. ${title}\n**URL:** ${link}\n**Snippet:** ${snippet}\n`);
+          }
+        }
+        
+        if (results.length === 0) {
+          return textResult(`No web search results found for: ${params.query}`);
+        }
+        
+        return textResult(`## Web Search Results for: "${params.query}"\n\n${results.join('\n')}\n\n*Note: Use web_fetch tool with any of the URLs above to read the full page content.*`);
+      } catch (err) {
+        return textResult(`Web search failed: ${formatToolError(err)}`);
+      }
+    }),
+  },
+
+  {
+    name: 'web_fetch',
+    label: 'Web Fetch',
+    description: 'Fetch the text content of any public URL. Extracts main text from HTML and converts it to Markdown. Use this to read external docs, repos, or articles.',
+    parameters: FetchUrlParams,
+    execute: safeExecute(async (_id, params: Static<typeof FetchUrlParams>) => {
+      let url = params.url;
+      if (!url.startsWith('http://') && !url.startsWith('https://')) {
+        url = 'https://' + url;
+      }
+      
+      try {
+        const res = await fetch(url, {
+          headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+          },
+          // Don't wait forever
+          signal: AbortSignal.timeout(10000)
+        });
+        
+        if (!res.ok) {
+          return textResult(`Failed to fetch URL: HTTP ${res.status} ${res.statusText}`);
+        }
+        
+        const contentType = res.headers.get('content-type') || '';
+        
+        // If it's a raw file (like raw.githubusercontent.com or a raw text file)
+        if (contentType.includes('text/plain') || contentType.includes('application/json') || url.includes('raw.githubusercontent.com')) {
+          const text = await res.text();
+          return textResult(truncate(text));
+        }
+        
+        // For HTML, we do a basic extraction (in a real app you might use JSDOM/Readability, but we'll do a robust regex cleanup here to avoid new dependencies)
+        let html = await res.text();
+        
+        // Extract title if possible
+        const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+        const title = titleMatch ? titleMatch[1].trim() : url;
+        
+        // Strip out scripts, styles, svg, and headers/footers roughly
+        html = html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, ' ')
+                   .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, ' ')
+                   .replace(/<svg\b[^<]*(?:(?!<\/svg>)<[^<]*)*<\/svg>/gi, ' ')
+                   .replace(/<header\b[^<]*(?:(?!<\/header>)<[^<]*)*<\/header>/gi, ' ')
+                   .replace(/<footer\b[^<]*(?:(?!<\/footer>)<[^<]*)*<\/footer>/gi, ' ')
+                   .replace(/<nav\b[^<]*(?:(?!<\/nav>)<[^<]*)*<\/nav>/gi, ' ');
+
+        // Convert some basic tags to markdown equivalents roughly before stripping all HTML
+        html = html.replace(/<h[1-2][^>]*>(.*?)<\/h[1-2]>/gi, '\n\n# $1\n\n')
+                   .replace(/<h[3-6][^>]*>(.*?)<\/h[3-6]>/gi, '\n\n## $1\n\n')
+                   .replace(/<p[^>]*>(.*?)<\/p>/gi, '\n\n$1\n\n')
+                   .replace(/<li[^>]*>(.*?)<\/li>/gi, '\n- $1')
+                   .replace(/<br\s*\/?>/gi, '\n');
+                   
+        // Strip remaining HTML tags
+        let text = html.replace(/<[^>]+>/g, ' ');
+        
+        // Decode common HTML entities
+        text = text.replace(/&nbsp;/g, ' ')
+                   .replace(/&amp;/g, ' ')
+                   .replace(/&lt;/g, '<')
+                   .replace(/&gt;/g, '>')
+                   .replace(/&quot;/g, '"')
+                   .replace(/&#39;/g, "'");
+
+        // Clean up whitespace: remove empty lines and extra spaces
+        text = text.replace(/[ \t]+/g, ' ')
+                   .replace(/\n\s*\n\s*\n/g, '\n\n')
+                   .trim();
+                   
+        const result = `# ${title}\nSource: ${url}\n\n${text}`;
+        return textResult(truncate(result));
+      } catch (err) {
+        return textResult(`Failed to fetch URL: ${formatToolError(err)}`);
+      }
+    }),
+  },
+
   {
     name: 'get_recent',
     label: 'Recent Files',
@@ -223,6 +422,28 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     }),
   },
 
+  {
+    name: 'batch_create_files',
+    label: 'Batch Create Files',
+    description: 'Create multiple new files in a single operation. Highly recommended when scaffolding new features or projects.',
+    parameters: BatchCreateFileParams,
+    execute: safeExecute(async (_id, params: Static<typeof BatchCreateFileParams>) => {
+      const created: string[] = [];
+      const errors: string[] = [];
+      for (const file of params.files) {
+        try {
+          createFile(file.path, file.content);
+          created.push(file.path);
+        } catch (e) {
+          errors.push(`${file.path}: ${formatToolError(e)}`);
+        }
+      }
+      let msg = `Batch creation complete.\nCreated ${created.length} files: ${created.join(', ')}`;
+      if (errors.length > 0) msg += `\n\nFailed to create ${errors.length} files:\n${errors.join('\n')}`;
+      return textResult(msg);
+    }),
+  },
+
   {
     name: 'append_to_file',
     label: 'Append to File',
@@ -237,7 +458,7 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
   {
     name: 'insert_after_heading',
     label: 'Insert After Heading',
-    description: 'Insert content right after a Markdown heading. Useful for adding items under a specific section.',
+    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>) => {
       insertAfterHeading(params.path, params.heading, params.content);
@@ -248,7 +469,7 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
   {
     name: 'update_section',
     label: 'Update Section',
-    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.',
+    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>) => {
       updateSection(params.path, params.heading, params.content);
@@ -256,6 +477,24 @@ export const knowledgeBaseTools: AgentTool<any>[] = [
     }),
   },
 
+  {
+    name: 'edit_lines',
+    label: 'Edit Lines',
+    description: 'Replace a specific range of lines with new content. Extremely reliable for precise edits. You must know the exact line numbers (use read_file_chunk to get them).',
+    parameters: EditLinesParams,
+    execute: safeExecute(async (_id, params: Static<typeof EditLinesParams>) => {
+      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 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}`);
+    }),
+  },
+
   {
     name: 'delete_file',
     label: 'Delete File',

package/app/lib/core/backlinks.ts

@@ -28,11 +28,19 @@ export function findBacklinks(mindRoot: string, targetPath: string): BacklinkEnt
     const lines = content.split('\n');
     for (let i = 0; i < lines.length; i++) {
       if (patterns.some(p => p.test(lines[i]))) {
-        const start = Math.max(0, i - 1);
-        const end = Math.min(lines.length - 1, i + 1);
-        const ctx = lines.slice(start, end + 1).join('\n').trim();
+        // Expand to a slightly larger context block for agent comprehension
+        // Attempt to find paragraph boundaries (empty lines) or cap at a reasonable size
+        let start = i;
+        while (start > 0 && start > i - 3 && lines[start].trim() !== '') start--;
+        let end = i;
+        while (end < lines.length - 1 && end < i + 3 && lines[end].trim() !== '') end++;
+        
+        let ctx = lines.slice(start, end + 1).join('\n').trim();
+        // Collapse multiple newlines in the context to save tokens, but keep simple structure
+        ctx = ctx.replace(/\n{2,}/g, ' ↵ ');
+        
         results.push({ source: filePath, line: i + 1, context: ctx });
-        break;
+        break; // currently only records the first match per file
       }
     }
   }

package/app/lib/core/file-convert.ts

@@ -0,0 +1,97 @@
+import path from 'path';
+
+export const ALLOWED_IMPORT_EXTENSIONS = new Set([
+  '.txt', '.md', '.markdown', '.csv', '.json', '.yaml', '.yml', '.xml', '.html', '.htm', '.pdf',
+]);
+
+export interface ConvertResult {
+  content: string;
+  originalName: string;
+  targetName: string;
+  metadata?: Record<string, string>;
+}
+
+export function sanitizeFileName(name: string): string {
+  let base = name.replace(/\\/g, '/').split('/').pop() ?? '';
+  base = base.replace(/\.\./g, '').replace(/^\/+/, '');
+  base = base.replace(/[\\:*?"<>|]/g, '-');
+  base = base.replace(/-{2,}/g, '-');
+  base = base.replace(/^[-\s]+|[-\s]+$/g, '');
+  return base || 'imported-file';
+}
+
+export function titleFromFileName(name: string): string {
+  const ext = path.extname(name);
+  const stem = (ext ? name.slice(0, -ext.length) : name).replace(/^\.+/, '');
+  const words = stem.replace(/[-_]+/g, ' ').trim().split(/\s+/);
+  if (words.length === 0 || (words.length === 1 && !words[0])) return 'Untitled';
+  return words.map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+}
+
+function stripHtmlTags(html: string): string {
+  return html
+    .replace(/<script[\s\S]*?<\/script>/gi, '')
+    .replace(/<style[\s\S]*?<\/style>/gi, '')
+    .replace(/<[^>]+>/g, '')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+export function convertToMarkdown(fileName: string, rawContent: string): ConvertResult {
+  const originalName = fileName;
+  const ext = path.extname(fileName).toLowerCase();
+  const stem = path.basename(fileName, ext) || 'note';
+  const title = titleFromFileName(fileName);
+
+  if (ext === '.md' || ext === '.markdown') {
+    return { content: rawContent, originalName, targetName: sanitizeFileName(fileName) };
+  }
+
+  if (ext === '.csv' || ext === '.json') {
+    return { content: rawContent, originalName, targetName: sanitizeFileName(fileName) };
+  }
+
+  if (ext === '.txt') {
+    return {
+      content: `# ${title}\n\n${rawContent}`,
+      originalName,
+      targetName: sanitizeFileName(`${stem}.md`),
+    };
+  }
+
+  if (ext === '.yaml' || ext === '.yml') {
+    return {
+      content: `# ${title}\n\n\`\`\`yaml\n${rawContent}\n\`\`\`\n`,
+      originalName,
+      targetName: sanitizeFileName(`${stem}.md`),
+    };
+  }
+
+  if (ext === '.html' || ext === '.htm') {
+    const text = stripHtmlTags(rawContent);
+    return {
+      content: `# ${title}\n\n${text}\n`,
+      originalName,
+      targetName: sanitizeFileName(`${stem}.md`),
+    };
+  }
+
+  if (ext === '.xml') {
+    return {
+      content: `# ${title}\n\n\`\`\`xml\n${rawContent}\n\`\`\`\n`,
+      originalName,
+      targetName: sanitizeFileName(`${stem}.md`),
+    };
+  }
+
+  return {
+    content: `# ${title}\n\n${rawContent}`,
+    originalName,
+    targetName: sanitizeFileName(`${stem}.md`),
+  };
+}

package/app/lib/core/organize.ts

@@ -0,0 +1,105 @@
+import fs from 'fs';
+import path from 'path';
+import { resolveSafe } from './security';
+import { appendContentChange } from './content-changes';
+
+export interface OrganizeResult {
+  readmeUpdated: boolean;
+  relatedFiles: Array<{ path: string; matchType: 'backlink' | 'keyword' }>;
+}
+
+const STOP_WORDS = new Set([
+  'the', 'a', 'an', 'is', 'of', 'and', 'for', 'to', 'in', 'on', 'at', 'by', 'or',
+  'not', 'but', 'with', 'from', 'this', 'that', 'was', 'are', 'be', 'has', 'had',
+  'readme', 'instruction', 'md',
+]);
+
+const SKIP_DIRS = new Set(['.git', 'node_modules', '.next', '.DS_Store']);
+
+function extractKeywords(filePath: string): string[] {
+  const stem = path.basename(filePath, path.extname(filePath));
+  return stem
+    .split(/[-_\s]+/)
+    .map(w => w.toLowerCase())
+    .filter(w => w.length >= 3 && !STOP_WORDS.has(w));
+}
+
+function collectMdFiles(dir: string, limit: number): string[] {
+  const results: string[] = [];
+  function walk(d: string) {
+    if (results.length >= limit) return;
+    let entries: fs.Dirent[];
+    try { entries = fs.readdirSync(d, { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      if (results.length >= limit) return;
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) walk(path.join(d, entry.name));
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        results.push(path.relative(dir, path.join(d, entry.name)).replace(/\\/g, '/'));
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+
+export function organizeAfterImport(
+  mindRoot: string,
+  createdFiles: string[],
+  targetSpace: string,
+): OrganizeResult {
+  for (const fp of createdFiles) {
+    try {
+      appendContentChange(mindRoot, {
+        op: 'import_file',
+        path: fp,
+        source: 'user',
+        summary: 'Imported file into knowledge base',
+      });
+    } catch { /* ignore */ }
+  }
+
+  let readmeUpdated = false;
+  const space = targetSpace.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '').trim();
+
+  if (space && createdFiles.length > 0) {
+    const readmePath = path.posix.join(space, 'README.md');
+    try {
+      const resolved = resolveSafe(mindRoot, readmePath);
+      if (fs.existsSync(resolved)) {
+        const existing = fs.readFileSync(resolved, 'utf-8');
+        const bullets = createdFiles.map(f => {
+          const base = path.posix.basename(f);
+          return `- [${base}](./${base})`;
+        }).join('\n');
+        fs.writeFileSync(resolved, `${existing.trimEnd()}\n\n${bullets}\n`, 'utf-8');
+        readmeUpdated = true;
+      }
+    } catch { /* README missing or write failed */ }
+  }
+
+  const createdSet = new Set(createdFiles);
+  const allKeywords = new Set<string>();
+  for (const f of createdFiles) {
+    for (const kw of extractKeywords(f)) allKeywords.add(kw);
+  }
+
+  const relatedFiles: OrganizeResult['relatedFiles'] = [];
+  if (allKeywords.size > 0) {
+    const candidates = collectMdFiles(mindRoot, 50);
+    const kwArray = [...allKeywords];
+    for (const candidate of candidates) {
+      if (createdSet.has(candidate)) continue;
+      if (relatedFiles.length >= 10) break;
+      try {
+        const resolved = resolveSafe(mindRoot, candidate);
+        const content = fs.readFileSync(resolved, 'utf-8').toLowerCase();
+        if (kwArray.some(kw => content.includes(kw))) {
+          relatedFiles.push({ path: candidate, matchType: 'keyword' });
+        }
+      } catch { /* ignore */ }
+    }
+  }
+
+  return { readmeUpdated, relatedFiles };
+}

package/app/lib/core/search.ts

@@ -91,9 +91,23 @@ export function searchFiles(mindRoot: string, query: string, opts: SearchOptions
     const index = lowerContent.indexOf(lowerQuery);
     if (index === -1) continue;
 
-    const snippetStart = Math.max(0, index - 60);
-    const snippetEnd = Math.min(content.length, index + query.length + 60);
-    let snippet = content.slice(snippetStart, snippetEnd).replace(/\n/g, ' ').trim();
+    // Try to find natural boundaries (paragraphs) around the match
+    let snippetStart = content.lastIndexOf('\n\n', index);
+    if (snippetStart === -1) snippetStart = Math.max(0, index - 200);
+    else snippetStart += 2; // skip the newlines
+
+    let snippetEnd = content.indexOf('\n\n', index);
+    if (snippetEnd === -1) snippetEnd = Math.min(content.length, index + query.length + 200);
+
+    // Prevent massive blocks (cap at ~400 chars total)
+    if (index - snippetStart > 200) snippetStart = index - 200;
+    if (snippetEnd - index > 200) snippetEnd = index + query.length + 200;
+
+    let snippet = content.slice(snippetStart, snippetEnd).trim();
+    
+    // Collapse internal whitespace for cleaner search result presentation, but preserve some structure
+    snippet = snippet.replace(/\n{3,}/g, '\n\n');
+    
     if (snippetStart > 0) snippet = '...' + snippet;
     if (snippetEnd < content.length) snippet += '...';
 

package/app/lib/fs.ts

@@ -525,8 +525,8 @@ function generateSnippet(
     }
   }
 
-  const snippetStart = Math.max(0, bestStart - 60);
-  const snippetEnd = Math.min(content.length, bestEnd + 61);
+  const snippetStart = Math.max(0, bestStart - 120);
+  const snippetEnd = Math.min(content.length, bestEnd + 120);
 
   let start = snippetStart;
   if (start > 0) {
@@ -539,7 +539,9 @@ function generateSnippet(
     if (spaceIdx > bestEnd) end = spaceIdx;
   }
 
-  let snippet = content.slice(start, end).replace(/\n/g, ' ').trim();
+  let snippet = content.slice(start, end).trim();
+  // Collapse multiple newlines into spaces but keep single newlines
+  snippet = snippet.replace(/\n{2,}/g, ' ↵ ');
   if (start > 0) snippet = '...' + snippet;
   if (end < content.length) snippet = snippet + '...';
   return snippet;

package/app/lib/i18n-en.ts

@@ -657,6 +657,57 @@ export const en = {
     convertToSpace: 'Convert to Space',
     deleteFolder: 'Delete Folder',
     confirmDeleteFolder: (name: string) => `Delete folder "${name}" and all its contents? This cannot be undone.`,
+    newFile: 'New File',
+    importFile: 'Import File',
+    importToSpace: 'Import file to this space',
+  },
+  fileImport: {
+    title: 'Import Files',
+    subtitle: 'Save files to your knowledge base or let AI organize them',
+    dropzoneText: 'Drag files here, or',
+    dropzoneButton: 'click to select',
+    dropzoneCompact: 'Drag more files, or',
+    dropzoneCompactButton: 'click to add',
+    dropzoneMobile: 'Tap to select files',
+    fileCount: (n: number) => `${n} file${n !== 1 ? 's' : ''}`,
+    clearAll: 'Clear all',
+    unsupported: 'Unsupported file type',
+    tooLarge: (max: string) => `File too large (max ${max})`,
+    archiveTitle: 'Save to Knowledge Base',
+    archiveDesc: 'Save as-is to a space',
+    digestTitle: 'AI Organize',
+    digestDesc: 'Extract key points into notes',
+    archiveConfigTitle: 'Save to Knowledge Base',
+    back: '← Back',
+    targetSpace: 'Target space',
+    rootDir: 'Root',
+    conflictLabel: 'If file already exists',
+    conflictRename: 'Auto-rename (add number suffix)',
+    conflictSkip: 'Skip',
+    conflictOverwrite: 'Overwrite existing file',
+    overwriteWarn: 'This will permanently replace existing file content',
+    cancel: 'Cancel',
+    importButton: (n: number) => `Save ${n} file${n !== 1 ? 's' : ''}`,
+    importing: 'Saving...',
+    preparing: 'Preparing...',
+    successToast: (n: number, space: string) => `Saved ${n} file${n !== 1 ? 's' : ''} to ${space || 'knowledge base'}`,
+    updatedIndex: (n: number) => `Updated ${n} index file${n !== 1 ? 's' : ''}`,
+    partialToast: (ok: number, total: number) => `Saved ${ok}/${total} files`,
+    skipReason: 'File already exists',
+    failToast: 'Import failed',
+    retry: 'Retry',
+    undo: 'Undo',
+    discardTitle: 'Discard import?',
+    discardMessage: (n: number) => `Discard ${n} selected file${n !== 1 ? 's' : ''}?`,
+    discardConfirm: 'Discard',
+    discardCancel: 'Cancel',
+    dropOverlay: 'Drop files to import into knowledge base',
+    dropOverlayFormats: 'Supports .md .txt .pdf .csv .json .yaml .html',
+    onboardingHint: 'Already have notes? Import files →',
+    digestPromptSingle: (name: string) => `Please read ${name}, extract key information and organize it into the appropriate place in my knowledge base.`,
+    digestPromptMulti: (n: number) => `Please read these ${n} files, extract key information and organize each into the appropriate place in my knowledge base.`,
+    arrowTo: '→',
+    remove: 'Remove',
   },
   dirView: {
     gridView: 'Grid view',