@geminilight/mindos 0.5.57 → 0.5.58

package/app/components/ask/AskContent.tsx

@@ -1,6 +1,6 @@
 'use client';
 
-import { useEffect, useRef, useState, useCallback } from 'react';
+import { useEffect, useLayoutEffect, useRef, useState, useCallback } from 'react';
 import { Sparkles, Send, AtSign, Paperclip, StopCircle, RotateCcw, History, X, Maximize2, Minimize2, PanelRight, AppWindow } from 'lucide-react';
 import { useLocale } from '@/lib/LocaleContext';
 import type { Message } from '@/lib/types';
@@ -21,6 +21,27 @@ const PANEL_COMPOSER_MIN = 84;
 const PANEL_COMPOSER_MAX_ABS = 440;
 const PANEL_COMPOSER_MAX_VIEW = 0.48;
 const PANEL_COMPOSER_KEY_STEP = 24;
+/** 输入框随内容增高，超过此行数后在框内滚动（与常见 IM 一致） */
+const PANEL_TEXTAREA_MAX_VISIBLE_LINES = 8;
+
+function syncPanelTextareaToContent(el: HTMLTextAreaElement, maxVisibleLines: number, availableHeight?: number): void {
+  const style = getComputedStyle(el);
+  const parsedLh = parseFloat(style.lineHeight);
+  const parsedFs = parseFloat(style.fontSize);
+  const fontSize = Number.isFinite(parsedFs) ? parsedFs : 14;
+  const lineHeight = Number.isFinite(parsedLh) ? parsedLh : fontSize * 1.375;
+  const pad =
+    (Number.isFinite(parseFloat(style.paddingTop)) ? parseFloat(style.paddingTop) : 0) +
+    (Number.isFinite(parseFloat(style.paddingBottom)) ? parseFloat(style.paddingBottom) : 0);
+  let maxH = lineHeight * maxVisibleLines + pad;
+  if (availableHeight && Number.isFinite(availableHeight) && availableHeight > 0) {
+    maxH = Math.min(maxH, availableHeight);
+  }
+  if (!Number.isFinite(maxH) || maxH <= 0) return;
+  el.style.height = '0px';
+  const next = Math.min(el.scrollHeight, maxH);
+  el.style.height = `${Number.isFinite(next) ? next : maxH}px`;
+}
 
 function panelComposerMaxForViewport(): number {
   if (typeof window === 'undefined') return PANEL_COMPOSER_MAX_ABS;
@@ -67,10 +88,18 @@ export default function AskContent({ visible, currentFile, initialMessage, onFir
   const firstMessageFired = useRef(false);
   const { t } = useLocale();
 
-  const [panelComposerHeight, setPanelComposerHeight] = useState(readStoredPanelComposerHeight);
+  const [panelComposerHeight, setPanelComposerHeight] = useState(PANEL_COMPOSER_DEFAULT);
   const panelComposerHRef = useRef(panelComposerHeight);
   panelComposerHRef.current = panelComposerHeight;
 
+  useEffect(() => {
+    const stored = readStoredPanelComposerHeight();
+    if (stored !== PANEL_COMPOSER_DEFAULT) {
+      setPanelComposerHeight(stored);
+      panelComposerHRef.current = stored;
+    }
+  }, []);
+
   const getPanelComposerHeight = useCallback(() => panelComposerHRef.current, []);
   const persistPanelComposerHeight = useCallback((h: number) => {
     try {
@@ -89,7 +118,11 @@ export default function AskContent({ visible, currentFile, initialMessage, onFir
     persist: persistPanelComposerHeight,
   });
 
-  const [panelComposerViewportMax, setPanelComposerViewportMax] = useState(panelComposerMaxForViewport);
+  const [panelComposerViewportMax, setPanelComposerViewportMax] = useState(PANEL_COMPOSER_MAX_ABS);
+
+  useEffect(() => {
+    setPanelComposerViewportMax(panelComposerMaxForViewport());
+  }, []);
 
   const applyPanelComposerClampAndPersist = useCallback(() => {
     const maxH = panelComposerMaxForViewport();
@@ -195,11 +228,28 @@ export default function AskContent({ visible, currentFile, initialMessage, onFir
     return () => window.removeEventListener('resize', applyPanelComposerClampAndPersist);
   }, [isPanel, applyPanelComposerClampAndPersist]);
 
+  const formRef = useRef<HTMLFormElement>(null);
+
+  useLayoutEffect(() => {
+    if (!isPanel || !visible) return;
+    const el = inputRef.current;
+    if (!el || !(el instanceof HTMLTextAreaElement)) return;
+    const form = formRef.current;
+    const availableH = form ? form.clientHeight - 40 : undefined;
+    syncPanelTextareaToContent(el, PANEL_TEXTAREA_MAX_VISIBLE_LINES, availableH);
+  }, [input, isPanel, isLoading, visible, panelComposerHeight]);
+
+  const mentionTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const handleInputChange = useCallback((val: string) => {
     setInput(val);
-    mention.updateMentionFromInput(val);
+    if (mentionTimerRef.current) clearTimeout(mentionTimerRef.current);
+    mentionTimerRef.current = setTimeout(() => mention.updateMentionFromInput(val), 80);
   }, [mention]);
 
+  useEffect(() => {
+    return () => { if (mentionTimerRef.current) clearTimeout(mentionTimerRef.current); };
+  }, []);
+
   const selectMention = useCallback((filePath: string) => {
     const atIdx = input.lastIndexOf('@');
     setInput(input.slice(0, atIdx));
@@ -498,6 +548,7 @@ export default function AskContent({ visible, currentFile, initialMessage, onFir
           )}
 
           <form
+            ref={formRef}
             onSubmit={handleSubmit}
             className={cn(
               'flex',
@@ -551,7 +602,7 @@ export default function AskContent({ visible, currentFile, initialMessage, onFir
               placeholder={t.ask.placeholder}
               disabled={isLoading}
               rows={1}
-              className="min-h-0 min-w-0 flex-1 resize-none overflow-y-auto bg-transparent py-2 text-sm leading-snug text-foreground placeholder:text-muted-foreground outline-none transition-[height] duration-75 disabled:opacity-50"
+              className="min-w-0 flex-1 resize-none overflow-y-auto bg-transparent py-2 text-sm leading-snug text-foreground placeholder:text-muted-foreground outline-none disabled:opacity-50"
             />
           ) : (
             <input
@@ -598,15 +649,6 @@ export default function AskContent({ visible, currentFile, initialMessage, onFir
             <kbd className="font-mono ml-0.5">↵</kbd> {t.ask.newlineHint}
           </span>
         ) : null}
-        {isPanel ? (
-          <span
-            className="hidden sm:inline"
-            suppressHydrationWarning
-            title={`${t.ask.panelComposerResize} · ${t.ask.panelComposerResetHint} · ${t.ask.panelComposerKeyboard}`}
-          >
-            <kbd className="font-mono">↕</kbd> {t.ask.panelComposerFooter}
-          </span>
-        ) : null}
         <span suppressHydrationWarning>
           <kbd className="font-mono">@</kbd> {t.ask.attachFile}
         </span>

package/app/lib/actions.ts

@@ -1,6 +1,7 @@
 'use server';
 
-import { createFile, deleteFile, renameFile } from '@/lib/fs';
+import { createFile, deleteFile, deleteDirectory, convertToSpace, renameFile, renameSpace, getMindRoot, invalidateCache } from '@/lib/fs';
+import { createSpaceFilesystem } from '@/lib/core/create-space';
 import { revalidatePath } from 'next/cache';
 
 export async function createFileAction(dirPath: string, fileName: string): Promise<{ success: boolean; filePath?: string; error?: string }> {
@@ -39,6 +40,55 @@ export async function renameFileAction(oldPath: string, newName: string): Promis
   }
 }
 
+export async function convertToSpaceAction(
+  dirPath: string,
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    convertToSpace(dirPath);
+    revalidatePath('/', 'layout');
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to convert to space' };
+  }
+}
+
+export async function deleteFolderAction(
+  dirPath: string,
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    deleteDirectory(dirPath);
+    revalidatePath('/', 'layout');
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to delete folder' };
+  }
+}
+
+export async function renameSpaceAction(
+  spacePath: string,
+  newName: string,
+): Promise<{ success: boolean; newPath?: string; error?: string }> {
+  try {
+    const newPath = renameSpace(spacePath, newName);
+    revalidatePath('/', 'layout');
+    return { success: true, newPath };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to rename space' };
+  }
+}
+
+export async function deleteSpaceAction(
+  spacePath: string,
+): Promise<{ success: boolean; error?: string }> {
+  try {
+    deleteDirectory(spacePath);
+    revalidatePath('/', 'layout');
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err instanceof Error ? err.message : 'Failed to delete space' };
+  }
+}
+
 /**
  * Create a new Mind Space (top-level directory) with README.md + auto-scaffolded INSTRUCTION.md.
  * The description is written into README.md so it appears on the homepage Space card
@@ -50,34 +100,12 @@ export async function createSpaceAction(
   parentPath: string = ''
 ): Promise<{ success: boolean; path?: string; error?: string }> {
   try {
-    const trimmed = name.trim();
-    if (!trimmed) return { success: false, error: 'Space name is required' };
-    if (trimmed.includes('/') || trimmed.includes('\\')) {
-      return { success: false, error: 'Space name must not contain path separators' };
-    }
-
-    // Sanitize parentPath — reject traversal attempts
-    const cleanParent = parentPath.replace(/\/+$/, '').trim();
-    if (cleanParent.includes('..') || cleanParent.startsWith('/') || cleanParent.includes('\\')) {
-      return { success: false, error: 'Invalid parent path' };
-    }
-
-    // Build full path: parentPath + name
-    const prefix = cleanParent ? cleanParent + '/' : '';
-    const fullPath = `${prefix}${trimmed}`;
-
-    // Strip emoji for clean title in README content
-    const cleanName = trimmed.replace(/^[\p{Emoji_Presentation}\p{Extended_Pictographic}\s]+/u, '') || trimmed;
-    const desc = description.trim() || '(Describe the purpose and usage of this space.)';
-    const readmeContent = `# ${cleanName}\n\n${desc}\n\n## 📁 Structure\n\n\`\`\`bash\n${fullPath}/\n├── INSTRUCTION.md\n├── README.md\n└── (your files here)\n\`\`\`\n\n## 💡 Usage\n\n(Add usage guidelines for this space.)\n`;
-
-    // createFile triggers scaffoldIfNewSpace → auto-generates INSTRUCTION.md
-    createFile(`${fullPath}/README.md`, readmeContent);
+    const { path: fullPath } = createSpaceFilesystem(getMindRoot(), name, description, parentPath);
+    invalidateCache();
     revalidatePath('/', 'layout');
     return { success: true, path: fullPath };
   } catch (err) {
     const msg = err instanceof Error ? err.message : 'Failed to create space';
-    // Make "already exists" error more user-friendly
     if (msg.includes('already exists')) {
       return { success: false, error: 'A space with this name already exists' };
     }

package/app/lib/core/create-space.ts

@@ -0,0 +1,36 @@
+import { MindOSError, ErrorCodes } from '@/lib/errors';
+import { createFile } from './fs-ops';
+
+/**
+ * Create a Mind Space on disk: `{fullPath}/README.md` plus scaffold from {@link createFile} / scaffoldIfNewSpace.
+ * Caller must invalidate app file-tree cache (e.g. `invalidateCache()` in `lib/fs.ts`).
+ */
+export function createSpaceFilesystem(
+  mindRoot: string,
+  name: string,
+  description: string,
+  parentPath = '',
+): { path: string } {
+  const trimmed = name.trim();
+  if (!trimmed) {
+    throw new MindOSError(ErrorCodes.INVALID_REQUEST, 'Space name is required', { name });
+  }
+  if (trimmed.includes('/') || trimmed.includes('\\')) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, 'Space name must not contain path separators', { name: trimmed });
+  }
+
+  const cleanParent = parentPath.replace(/\/+$/, '').trim();
+  if (cleanParent.includes('..') || cleanParent.startsWith('/') || cleanParent.includes('\\')) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, 'Invalid parent path', { parentPath });
+  }
+
+  const prefix = cleanParent ? `${cleanParent}/` : '';
+  const fullPath = `${prefix}${trimmed}`;
+
+  const cleanName = trimmed.replace(/^[\p{Emoji_Presentation}\p{Extended_Pictographic}\s]+/u, '') || trimmed;
+  const desc = description.trim() || '(Describe the purpose and usage of this space.)';
+  const readmeContent = `# ${cleanName}\n\n${desc}\n\n## 📁 Structure\n\n\`\`\`bash\n${fullPath}/\n├── INSTRUCTION.md\n├── README.md\n└── (your files here)\n\`\`\`\n\n## 💡 Usage\n\n(Add usage guidelines for this space.)\n`;
+
+  createFile(mindRoot, `${fullPath}/README.md`, readmeContent);
+  return { path: fullPath };
+}

package/app/lib/core/fs-ops.ts

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { resolveSafe, assertWithinRoot } from './security';
 import { MindOSError, ErrorCodes } from '@/lib/errors';
-import { scaffoldIfNewSpace } from './space-scaffold';
+import { scaffoldIfNewSpace, cleanDirName, INSTRUCTION_TEMPLATE, README_TEMPLATE } from './space-scaffold';
 
 /**
  * Reads the content of a file given a relative path from mindRoot.
@@ -55,6 +55,48 @@ export function deleteFile(mindRoot: string, filePath: string): void {
   fs.unlinkSync(resolved);
 }
 
+/**
+ * Recursively deletes a directory and all its contents.
+ * Throws if the path does not exist, is outside mindRoot, or is not a directory.
+ */
+export function deleteDirectory(mindRoot: string, dirPath: string): void {
+  const resolved = resolveSafe(mindRoot, dirPath);
+  if (!fs.existsSync(resolved)) {
+    throw new MindOSError(ErrorCodes.FILE_NOT_FOUND, `Directory not found: ${dirPath}`, { dirPath });
+  }
+  if (!fs.statSync(resolved).isDirectory()) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, `Not a directory: ${dirPath}`, { dirPath });
+  }
+  fs.rmSync(resolved, { recursive: true, force: true });
+}
+
+/**
+ * Converts an existing directory into a Space by creating INSTRUCTION.md
+ * (and README.md if missing). Idempotent — skips files that already exist.
+ */
+export function convertToSpace(mindRoot: string, dirPath: string): void {
+  const resolved = resolveSafe(mindRoot, dirPath);
+  if (!fs.existsSync(resolved)) {
+    throw new MindOSError(ErrorCodes.FILE_NOT_FOUND, `Directory not found: ${dirPath}`, { dirPath });
+  }
+  if (!fs.statSync(resolved).isDirectory()) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, `Not a directory: ${dirPath}`, { dirPath });
+  }
+
+  const dirName = path.basename(resolved);
+  const name = cleanDirName(dirName);
+
+  const instructionPath = path.join(resolved, 'INSTRUCTION.md');
+  if (!fs.existsSync(instructionPath)) {
+    fs.writeFileSync(instructionPath, INSTRUCTION_TEMPLATE(name), 'utf-8');
+  }
+
+  const readmePath = path.join(resolved, 'README.md');
+  if (!fs.existsSync(readmePath)) {
+    fs.writeFileSync(readmePath, README_TEMPLATE(name), 'utf-8');
+  }
+}
+
 /**
  * Renames a file within its current directory.
  * newName must be a plain filename (no path separators).
@@ -79,6 +121,41 @@ export function renameFile(mindRoot: string, oldPath: string, newName: string):
   return path.relative(root, newResolved);
 }
 
+/**
+ * Renames a directory (Mind Space) under mindRoot. `newName` must be a single segment (no `/` or `\\`).
+ * Does not rewrite links inside markdown files.
+ */
+export function renameSpaceDirectory(mindRoot: string, spacePath: string, newName: string): string {
+  const trimmedName = newName.trim();
+  if (!trimmedName || trimmedName.includes('/') || trimmedName.includes('\\')) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, 'Invalid space name: must not contain path separators', { newName });
+  }
+  const normalized = spacePath.replace(/\/+$/g, '').trim();
+  if (!normalized) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, 'Space path is required', { spacePath });
+  }
+
+  const root = path.resolve(mindRoot);
+  const oldResolved = resolveSafe(mindRoot, normalized);
+  if (!fs.existsSync(oldResolved)) {
+    throw new MindOSError(ErrorCodes.FILE_NOT_FOUND, `Space not found: ${normalized}`, { spacePath: normalized });
+  }
+  if (!fs.statSync(oldResolved).isDirectory()) {
+    throw new MindOSError(ErrorCodes.INVALID_PATH, `Not a directory: ${normalized}`, { spacePath: normalized });
+  }
+
+  const parentDir = path.dirname(oldResolved);
+  const newResolved = path.join(parentDir, trimmedName);
+  assertWithinRoot(newResolved, root);
+
+  if (fs.existsSync(newResolved)) {
+    throw new MindOSError(ErrorCodes.FILE_ALREADY_EXISTS, 'A space with that name already exists', { newName: trimmedName });
+  }
+
+  fs.renameSync(oldResolved, newResolved);
+  return path.relative(root, newResolved);
+}
+
 /**
  * Moves a file from one path to another within mindRoot.
  * Returns the new path and a list of files that referenced the old path.

package/app/lib/core/index.ts

@@ -22,7 +22,10 @@ export {
   writeFile,
   createFile,
   deleteFile,
+  deleteDirectory,
+  convertToSpace,
   renameFile,
+  renameSpaceDirectory,
   moveFile,
   getRecentlyModified,
 } from './fs-ops';
@@ -56,3 +59,8 @@ export { findBacklinks } from './backlinks';
 
 // Git
 export { isGitRepo, gitLog, gitShowFile } from './git';
+
+// Mind Space
+export { createSpaceFilesystem } from './create-space';
+export { summarizeTopLevelSpaces } from './list-spaces';
+export type { MindSpaceSummary } from './list-spaces';

package/app/lib/core/types.ts

@@ -1,3 +1,8 @@
+export interface SpacePreview {
+  instructionLines: string[];
+  readmeLines: string[];
+}
+
 export interface FileNode {
   name: string;
   path: string;
@@ -5,6 +10,8 @@ export interface FileNode {
   children?: FileNode[];
   extension?: string;
   mtime?: number;
+  isSpace?: boolean;
+  spacePreview?: SpacePreview;
 }
 
 export interface SearchResult {

package/app/lib/fs.ts

@@ -7,7 +7,10 @@ import {
   writeFile as coreWriteFile,
   createFile as coreCreateFile,
   deleteFile as coreDeleteFile,
+  deleteDirectory as coreDeleteDirectory,
+  convertToSpace as coreConvertToSpace,
   renameFile as coreRenameFile,
+  renameSpaceDirectory as coreRenameSpaceDirectory,
   moveFile as coreMoveFile,
   readLines as coreReadLines,
   insertLines as coreInsertLines,
@@ -21,8 +24,10 @@ import {
   gitLog as coreGitLog,
   gitShowFile as coreGitShowFile,
   invalidateSearchIndex,
+  summarizeTopLevelSpaces,
 } from './core';
-import { FileNode } from './core/types';
+import type { MindSpaceSummary } from './core';
+import { FileNode, SpacePreview } from './core/types';
 import { SearchMatch } from './types';
 import { effectiveSopRoot } from './settings';
 
@@ -77,8 +82,31 @@ function ensureCache(): FileTreeCache {
 
 // ─── Internal builders ────────────────────────────────────────────────────────
 
-function buildFileTree(dirPath: string): FileNode[] {
-  const root = getMindRoot();
+const SPACE_PREVIEW_MAX_LINES = 3;
+
+function extractBodyLines(filePath: string, maxLines: number): string[] {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const bodyLines: string[] = [];
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      bodyLines.push(trimmed);
+      if (bodyLines.length >= maxLines) break;
+    }
+    return bodyLines;
+  } catch { return []; }
+}
+
+function buildSpacePreview(dirAbsPath: string) {
+  return {
+    instructionLines: extractBodyLines(path.join(dirAbsPath, 'INSTRUCTION.md'), SPACE_PREVIEW_MAX_LINES),
+    readmeLines: extractBodyLines(path.join(dirAbsPath, 'README.md'), SPACE_PREVIEW_MAX_LINES),
+  };
+}
+
+function buildFileTree(dirPath: string, rootOverride?: string): FileNode[] {
+  const root = rootOverride ?? getMindRoot();
   let entries: fs.Dirent[];
   try {
     entries = fs.readdirSync(dirPath, { withFileTypes: true });
@@ -94,9 +122,15 @@ function buildFileTree(dirPath: string): FileNode[] {
 
     if (entry.isDirectory()) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const children = buildFileTree(fullPath);
+      const children = buildFileTree(fullPath, root);
       if (children.length > 0) {
-        nodes.push({ name: entry.name, path: relativePath, type: 'directory', children });
+        const hasInstruction = children.some(c => c.type === 'file' && c.name === 'INSTRUCTION.md');
+        const node: FileNode = { name: entry.name, path: relativePath, type: 'directory', children };
+        if (hasInstruction) {
+          node.isSpace = true;
+          node.spacePreview = buildSpacePreview(fullPath);
+        }
+        nodes.push(node);
       }
     } else if (entry.isFile()) {
       const ext = path.extname(entry.name).toLowerCase();
@@ -114,6 +148,11 @@ function buildFileTree(dirPath: string): FileNode[] {
   return nodes;
 }
 
+/** Exposed for testing only — builds a file tree from an arbitrary root path. */
+export function buildFileTreeForTest(rootPath: string): FileNode[] {
+  return buildFileTree(rootPath, rootPath);
+}
+
 function buildAllFiles(dirPath: string): string[] {
   const root = getMindRoot();
   let entries: fs.Dirent[];
@@ -146,6 +185,20 @@ export function getFileTree(): FileNode[] {
   return ensureCache().tree;
 }
 
+/** Top-level Mind Spaces (same cached tree as home Spaces grid). */
+export function listMindSpaces(): MindSpaceSummary[] {
+  return summarizeTopLevelSpaces(getMindRoot(), ensureCache().tree);
+}
+
+/** Returns space preview (INSTRUCTION + README excerpts) for a directory, or null if not a space. */
+export function getSpacePreview(dirPath: string): SpacePreview | null {
+  const root = getMindRoot();
+  const abs = path.join(root, dirPath);
+  const instructionPath = path.join(abs, 'INSTRUCTION.md');
+  if (!fs.existsSync(instructionPath)) return null;
+  return buildSpacePreview(abs);
+}
+
 /** Returns cached list of all file paths (relative to MIND_ROOT). */
 export function collectAllFiles(): string[] {
   return ensureCache().allFiles;
@@ -251,6 +304,25 @@ export function renameFile(oldPath: string, newName: string): string {
   return result;
 }
 
+/** Renames a Space directory under MIND_ROOT. newName must be a single path segment. */
+export function renameSpace(spacePath: string, newName: string): string {
+  const result = coreRenameSpaceDirectory(getMindRoot(), spacePath, newName);
+  invalidateCache();
+  return result;
+}
+
+/** Recursively deletes a directory under MIND_ROOT. */
+export function deleteDirectory(dirPath: string): void {
+  coreDeleteDirectory(getMindRoot(), dirPath);
+  invalidateCache();
+}
+
+/** Converts a regular folder into a Space by adding INSTRUCTION.md + README.md. */
+export function convertToSpace(dirPath: string): void {
+  coreConvertToSpace(getMindRoot(), dirPath);
+  invalidateCache();
+}
+
 // ─── Public API: Line-level operations (delegated to @mindos/core) ───────────
 
 export function readLines(filePath: string): string[] {
@@ -471,6 +543,7 @@ export function gitShowFile(filePath: string, commit: string): string {
 
 import type { BacklinkEntry } from './core/types';
 export type { BacklinkEntry } from './core/types';
+export type { MindSpaceSummary } from './core';
 
 export function findBacklinks(targetPath: string): BacklinkEntry[] {
   return coreFindBacklinks(getMindRoot(), targetPath);

package/app/lib/i18n-en.ts

@@ -278,6 +278,16 @@ export const en = {
     enterFileName: 'Enter a file name',
     failed: 'Failed',
     confirmDelete: (name: string) => `Delete "${name}"? This cannot be undone.`,
+    rules: 'Rules',
+    about: 'About',
+    viewAll: 'View all',
+    editRules: 'Edit Rules',
+    renameSpace: 'Rename Space',
+    deleteSpace: 'Delete Space',
+    confirmDeleteSpace: (name: string) => `Delete space "${name}" and all its files? This cannot be undone.`,
+    convertToSpace: 'Convert to Space',
+    deleteFolder: 'Delete Folder',
+    confirmDeleteFolder: (name: string) => `Delete folder "${name}" and all its contents? This cannot be undone.`,
   },
   dirView: {
     gridView: 'Grid view',

package/app/lib/i18n-zh.ts

@@ -302,6 +302,16 @@ export const zh = {
     enterFileName: '请输入文件名',
     failed: '操作失败',
     confirmDelete: (name: string) => `确定删除「${name}」？此操作不可撤销。`,
+    rules: '规则',
+    about: '说明',
+    viewAll: '查看全部',
+    editRules: '编辑规则',
+    renameSpace: '重命名空间',
+    deleteSpace: '删除空间',
+    confirmDeleteSpace: (name: string) => `删除空间「${name}」及其所有文件？此操作不可撤销。`,
+    convertToSpace: '转为空间',
+    deleteFolder: '删除文件夹',
+    confirmDeleteFolder: (name: string) => `删除文件夹「${name}」及其所有内容？此操作不可撤销。`,
   },
   dirView: {
     gridView: '网格视图',

package/mcp/README.md

@@ -1,6 +1,6 @@
 # MindOS MCP Server
 
-Pure HTTP client wrapper that maps 20 MCP tools to the App REST API via `fetch`. Zero business logic — all operations are delegated to the App.
+Pure HTTP client wrapper that maps 22 MCP tools to the App REST API via `fetch`. Zero business logic — all operations are delegated to the App.
 
 ## Architecture
 
@@ -41,7 +41,7 @@ MCP_TRANSPORT=stdio mindos mcp   # stdio mode
 | `MCP_PORT` | `8781` | HTTP listen port (configurable via `mindos onboard`) |
 | `MCP_ENDPOINT` | `/mcp` | HTTP endpoint path |
 
-## MCP Tools (20)
+## MCP Tools (22)
 
 | Tool | App API | Description |
 |------|---------|-------------|
@@ -49,6 +49,8 @@ MCP_TRANSPORT=stdio mindos mcp   # stdio mode
 | `mindos_read_file` | `GET /api/file?path=...` | Read file content (with offset/limit pagination) |
 | `mindos_write_file` | `POST /api/file` op=save_file | Overwrite file content |
 | `mindos_create_file` | `POST /api/file` op=create_file | Create a new .md or .csv file |
+| `mindos_create_space` | `POST /api/file` op=create_space | Create a Mind Space (README + INSTRUCTION scaffold) |
+| `mindos_rename_space` | `POST /api/file` op=rename_space | Rename a Space directory (folder only) |
 | `mindos_delete_file` | `POST /api/file` op=delete_file | Delete a file |
 | `mindos_rename_file` | `POST /api/file` op=rename_file | Rename a file (same directory) |
 | `mindos_move_file` | `POST /api/file` op=move_file | Move a file to a new path |

package/mcp/src/index.ts

@@ -173,6 +173,56 @@ server.registerTool("mindos_create_file", {
   } catch (e) { logOp("mindos_create_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
+// ── mindos_create_space ─────────────────────────────────────────────────────
+
+server.registerTool("mindos_create_space", {
+  title: "Create Mind Space",
+  description:
+    "Create a new Mind Space (top-level or under parent_path): directory + README.md + INSTRUCTION.md scaffold. Use this instead of create_file when adding a new cognitive zone to the knowledge base.",
+  inputSchema: z.object({
+    name: z.string().min(1).describe("Space directory name (no path separators)"),
+    description: z.string().default("").describe("Short purpose text stored in README.md"),
+    parent_path: z.string().default("").describe("Optional parent directory under MIND_ROOT (empty = top-level Space)"),
+  }),
+}, async ({ name, description, parent_path }) => {
+  try {
+    const json = await post("/api/file", {
+      op: "create_space",
+      path: "_",
+      name,
+      description,
+      parent_path,
+    });
+    const p = json.path as string;
+    logOp("mindos_create_space", { name, parent_path }, "ok", p);
+    return ok(`Created Mind Space at "${p}"`);
+  } catch (e) {
+    logOp("mindos_create_space", { name, parent_path }, "error", String(e));
+    return error(String(e));
+  }
+});
+
+// ── mindos_rename_space ─────────────────────────────────────────────────────
+
+server.registerTool("mindos_rename_space", {
+  title: "Rename Mind Space",
+  description:
+    "Rename a Space directory (relative path to the folder, e.g. Notes or Work/Notes). Only the final folder name changes; new_name must be a single segment. Does not rewrite links inside files.",
+  inputSchema: z.object({
+    path: z.string().min(1).describe("Relative path to the space directory to rename"),
+    new_name: z.string().min(1).describe("New folder name only (no slashes)"),
+  }),
+}, async ({ path: spacePath, new_name }) => {
+  try {
+    const json = await post("/api/file", { op: "rename_space", path: spacePath, new_name });
+    logOp("mindos_rename_space", { path: spacePath, new_name }, "ok", String(json.newPath));
+    return ok(`Renamed space "${spacePath}" → "${json.newPath}"`);
+  } catch (e) {
+    logOp("mindos_rename_space", { path: spacePath, new_name }, "error", String(e));
+    return error(String(e));
+  }
+});
+
 // ── mindos_delete_file ──────────────────────────────────────────────────────
 
 server.registerTool("mindos_delete_file", {

package/package.json

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