@geminilight/mindos 0.5.68 → 0.5.69

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

@@ -357,21 +357,29 @@ export async function POST(req: NextRequest) {
         contextStrategy,
       ),
 
-      // Write-protection: block writes to protected files
+      // Write-protection: block writes to protected files gracefully
       beforeToolCall: async (context: BeforeToolCallContext): Promise<BeforeToolCallResult | undefined> => {
         const { toolCall, args } = context;
         // toolCall is an object with type "toolCall" and contains the tool name and ID
         const toolName = (toolCall as any).toolName ?? (toolCall as any).name;
         if (toolName && WRITE_TOOLS.has(toolName)) {
-          const filePath = (args as any).path ?? (args as any).from_path;
-          if (filePath) {
+          // Special handling for batch creations where we need to check multiple files
+          const pathsToCheck: string[] = [];
+          if (toolName === 'batch_create_files' && Array.isArray((args as any).files)) {
+            (args as any).files.forEach((f: any) => { if (f.path) pathsToCheck.push(f.path); });
+          } else {
+            const singlePath = (args as any).path ?? (args as any).from_path;
+            if (singlePath) pathsToCheck.push(singlePath);
+          }
+
+          for (const filePath of pathsToCheck) {
             try {
               assertNotProtected(filePath, 'modified by AI agent');
             } catch (e) {
               const errorMsg = e instanceof Error ? e.message : String(e);
               return {
                 block: true,
-                reason: `Write-protection error: ${errorMsg}`,
+                reason: `Write-protection error: ${errorMsg}. You CANNOT modify ${filePath} because it is system-protected. Please tell the user you don't have permission to do this.`,
               };
             }
           }

package/app/app/api/mcp/install/route.ts

@@ -11,6 +11,82 @@ function parseJsonc(text: string): Record<string, unknown> {
   return JSON.parse(stripped);
 }
 
+/** Ensure nested object path exists and return the leaf container */
+function ensureNestedPath(obj: Record<string, unknown>, dotPath: string): Record<string, unknown> {
+  const parts = dotPath.split('.').filter(Boolean);
+  let current = obj;
+  for (const part of parts) {
+    if (!current[part] || typeof current[part] !== 'object') {
+      current[part] = {};
+    }
+    current = current[part] as Record<string, unknown>;
+  }
+  return current;
+}
+
+/** Generate a TOML section string for an MCP entry */
+function buildTomlEntry(sectionKey: string, serverName: string, entry: Record<string, unknown>): string {
+  const lines: string[] = [];
+  lines.push(`[${sectionKey}.${serverName}]`);
+  if (entry.type) lines.push(`type = "${entry.type}"`);
+  if (entry.command) lines.push(`command = "${entry.command}"`);
+  if (entry.url) lines.push(`url = "${entry.url}"`);
+  if (Array.isArray(entry.args)) {
+    lines.push(`args = [${entry.args.map(a => `"${a}"`).join(', ')}]`);
+  }
+  if (entry.env && typeof entry.env === 'object') {
+    lines.push('');
+    lines.push(`[${sectionKey}.${serverName}.env]`);
+    for (const [k, v] of Object.entries(entry.env)) {
+      lines.push(`${k} = "${v}"`);
+    }
+  }
+  if (entry.headers && typeof entry.headers === 'object') {
+    lines.push('');
+    lines.push(`[${sectionKey}.${serverName}.headers]`);
+    for (const [k, v] of Object.entries(entry.headers)) {
+      lines.push(`${k} = "${v}"`);
+    }
+  }
+  return lines.join('\n');
+}
+
+/** Replace or append a [section.server] block in a TOML file */
+function mergeTomlEntry(existing: string, sectionKey: string, serverName: string, entry: Record<string, unknown>): string {
+  const sectionHeader = `[${sectionKey}.${serverName}]`;
+  const envHeader = `[${sectionKey}.${serverName}.env]`;
+  const headersHeader = `[${sectionKey}.${serverName}.headers]`;
+  const newBlock = buildTomlEntry(sectionKey, serverName, entry);
+
+  const lines = existing.split('\n');
+  const result: string[] = [];
+  let skipping = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === sectionHeader || trimmed === envHeader || trimmed === headersHeader) {
+      skipping = true;
+      continue;
+    }
+    if (skipping && trimmed.startsWith('[')) {
+      skipping = false;
+    }
+    if (!skipping) {
+      result.push(line);
+    }
+  }
+
+  // Remove trailing blank lines before appending
+  while (result.length > 0 && result[result.length - 1].trim() === '') {
+    result.pop();
+  }
+  result.push('');
+  result.push(newBlock);
+  result.push('');
+
+  return result.join('\n');
+}
+
 interface AgentInstallItem {
   key: string;
   scope: 'project' | 'global';
@@ -96,20 +172,31 @@ export async function POST(req: NextRequest) {
       const absPath = expandHome(configPath);
 
       try {
-        // Read existing config
-        let config: Record<string, unknown> = {};
-        if (fs.existsSync(absPath)) {
-          config = parseJsonc(fs.readFileSync(absPath, 'utf-8'));
-        }
-
-        // Merge — only touch mcpServers.mindos
-        if (!config[agent.key]) config[agent.key] = {};
-        (config[agent.key] as Record<string, unknown>).mindos = entry;
-
-        // Write
         const dir = path.dirname(absPath);
         if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(absPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+        if (agent.format === 'toml') {
+          // TOML format (e.g. Codex): merge into existing TOML or generate new
+          const existing = fs.existsSync(absPath) ? fs.readFileSync(absPath, 'utf-8') : '';
+          const merged = mergeTomlEntry(existing, agent.key, 'mindos', entry as Record<string, unknown>);
+          fs.writeFileSync(absPath, merged, 'utf-8');
+        } else {
+          // JSON format (default)
+          let config: Record<string, unknown> = {};
+          if (fs.existsSync(absPath)) {
+            config = parseJsonc(fs.readFileSync(absPath, 'utf-8'));
+          }
+
+          // For global scope with nested key (e.g. VS Code: mcp.servers),
+          // write to the nested path instead of the flat key
+          const useNestedKey = isGlobal && agent.globalNestedKey;
+          const container = useNestedKey
+            ? ensureNestedPath(config, agent.globalNestedKey!)
+            : (() => { if (!config[agent.key]) config[agent.key] = {}; return config[agent.key] as Record<string, unknown>; })();
+          container.mindos = entry;
+
+          fs.writeFileSync(absPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+        }
 
         const result: typeof results[number] = { agent: key, status: 'ok', path: configPath, transport: effectiveTransport };
 

package/app/app/api/mcp/status/route.ts

@@ -50,7 +50,7 @@ export async function GET(req: NextRequest) {
       transport: 'http',
       endpoint,
       port,
-      toolCount: running ? 20 : 0,
+      toolCount: running ? 23 : 0,
       authConfigured,
       // Masked for display; full token only used server-side in snippet generation
       maskedToken: authConfigured ? maskToken(token) : undefined,

package/app/components/agents/SkillDetailPopover.tsx

@@ -136,6 +136,8 @@ export default function SkillDetailPopover({
       setLoadError(false);
       setCopied(false);
       setDeleteMsg(null);
+      setDeleting(false);
+      setToggleBusy(false);
       fetchContent();
     }
   }, [open, skillName, fetchContent]);

package/app/lib/agent/context.ts

@@ -227,7 +227,7 @@ export async function compactMessages(
 
     console.log(`[ask] Compacted ${earlyMessages.length} early messages into summary (${summaryText.length} chars)`);
 
-    const summaryContent = `[Summary of earlier conversation]\n\n${summaryText}`;
+    const summaryContent = `[System Note: Older conversation history has been truncated due to context length limits, but here is an AI-generated summary of what was discussed so far.]\n\n${summaryText}`;
 
     // If first recent message is also 'user', merge summary into it to avoid
     // consecutive user messages (Anthropic rejects user→user sequences).
@@ -316,10 +316,15 @@ export function hardPrune(
     console.log(`[ask] Hard pruned ${cutIdx} messages, injecting synthetic user message (${messages.length} → ${pruned.length + 1})`);
     const syntheticUser: UserMessage = {
       role: 'user',
-      content: '[Conversation context was pruned due to length. Continuing from here.]',
+      content: '[System Note: Older conversation history has been truncated due to context length limits. The user may refer to things you can no longer see. If so, kindly ask them to repeat the context.]',
       timestamp: Date.now(),
     };
     return [syntheticUser as AgentMessage, ...pruned];
+  } else if (cutIdx > 0 && pruned.length > 0 && (pruned[0] as any).role === 'user') {
+    // If we pruned and the first message IS a user message, prepend the warning to it
+    const firstMsg = { ...pruned[0] } as UserMessage;
+    firstMsg.content = `[System Note: Older conversation history has been truncated due to context length limits. The user may refer to things you can no longer see. If so, kindly ask them to repeat the context.]\n\n` + firstMsg.content;
+    pruned[0] = firstMsg as AgentMessage;
   }
 
   if (cutIdx > 0) {

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,6 +82,13 @@ 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' }),
@@ -86,6 +106,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 +142,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 +198,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',
@@ -223,6 +276,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 +312,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 +323,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 +331,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.5.68",
+  "version": "0.5.69",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",