@geminilight/mindos 0.6.72 → 0.6.73

package/_standalone/__tests__/core/create-space.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { mkTempMindRoot, cleanupMindRoot, readSeeded } from './helpers';
+import { createSpaceFilesystem } from '@/lib/core/create-space';
+
+describe('createSpaceFilesystem', () => {
+  let mindRoot: string;
+
+  beforeEach(() => {
+    mindRoot = mkTempMindRoot();
+  });
+  afterEach(() => {
+    cleanupMindRoot(mindRoot);
+  });
+
+  it('creates README and triggers INSTRUCTION scaffold for top-level space', () => {
+    const { path: p } = createSpaceFilesystem(mindRoot, 'Zeta', 'desc here', '');
+    expect(p).toBe('Zeta');
+    expect(readSeeded(mindRoot, 'Zeta/README.md')).toContain('desc here');
+    expect(fs.existsSync(path.join(mindRoot, 'Zeta', 'INSTRUCTION.md'))).toBe(true);
+  });
+
+  it('throws for empty name', () => {
+    expect(() => createSpaceFilesystem(mindRoot, '  ', 'd', '')).toThrow('Space name is required');
+  });
+
+  it('creates INSTRUCTION.md for nested space under existing parent', () => {
+    createSpaceFilesystem(mindRoot, 'Parent', 'top', '');
+    createSpaceFilesystem(mindRoot, 'Child', 'nested', 'Parent');
+    expect(fs.existsSync(path.join(mindRoot, 'Parent', 'Child', 'INSTRUCTION.md'))).toBe(true);
+    expect(readSeeded(mindRoot, 'Parent/Child/README.md')).toContain('nested');
+  });
+
+  it('throws when space README path already exists', () => {
+    createSpaceFilesystem(mindRoot, 'Dup', 'a', '');
+    expect(() => createSpaceFilesystem(mindRoot, 'Dup', 'b', '')).toThrow('already exists');
+  });
+});

package/_standalone/__tests__/core/csv.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkTempMindRoot, cleanupMindRoot, seedFile, readSeeded } from './helpers';
+import { appendCsvRow } from '@/lib/core/csv';
+
+describe('csv', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('appends a simple row', () => {
+    seedFile(mindRoot, 'data.csv', 'name,value\n');
+    const { newRowCount } = appendCsvRow(mindRoot, 'data.csv', ['foo', 'bar']);
+    expect(newRowCount).toBe(2);
+    expect(readSeeded(mindRoot, 'data.csv')).toBe('name,value\nfoo,bar\n');
+  });
+
+  it('escapes cells with commas', () => {
+    seedFile(mindRoot, 'data.csv', 'a,b\n');
+    appendCsvRow(mindRoot, 'data.csv', ['hello, world', 'plain']);
+    const content = readSeeded(mindRoot, 'data.csv');
+    expect(content).toContain('"hello, world"');
+  });
+
+  it('escapes cells with quotes (RFC 4180)', () => {
+    seedFile(mindRoot, 'data.csv', 'a,b\n');
+    appendCsvRow(mindRoot, 'data.csv', ['say "hello"', 'ok']);
+    const content = readSeeded(mindRoot, 'data.csv');
+    expect(content).toContain('"say ""hello"""');
+  });
+
+  it('escapes cells with newlines', () => {
+    seedFile(mindRoot, 'data.csv', 'a,b\n');
+    appendCsvRow(mindRoot, 'data.csv', ['line1\nline2', 'ok']);
+    const content = readSeeded(mindRoot, 'data.csv');
+    expect(content).toContain('"line1\nline2"');
+  });
+
+  it('creates parent directories if needed', () => {
+    appendCsvRow(mindRoot, 'new/dir/data.csv', ['a', 'b']);
+    const content = readSeeded(mindRoot, 'new/dir/data.csv');
+    expect(content).toBe('a,b\n');
+  });
+
+  it('throws for non-.csv files', () => {
+    seedFile(mindRoot, 'test.md', '');
+    expect(() => appendCsvRow(mindRoot, 'test.md', ['a'])).toThrow('.csv');
+  });
+});

package/_standalone/__tests__/core/detect-agents.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import { execSync } from 'child_process';
+import { detectAgentPresence, MCP_AGENTS } from '@/lib/mcp-agents';
+
+vi.mock('child_process', () => ({
+  execSync: vi.fn(),
+}));
+
+const mockExecSync = vi.mocked(execSync);
+
+describe('detectAgentPresence', () => {
+  let existsSyncSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    existsSyncSpy = vi.spyOn(fs, 'existsSync');
+    mockExecSync.mockReset();
+    existsSyncSpy.mockReset();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('returns false for unknown agent key', () => {
+    expect(detectAgentPresence('nonexistent-agent')).toBe(false);
+  });
+
+  it('returns true when CLI is found via which', () => {
+    mockExecSync.mockReturnValue(Buffer.from('/usr/bin/claude'));
+    existsSyncSpy.mockReturnValue(false);
+    expect(detectAgentPresence('claude-code')).toBe(true);
+  });
+
+  it('returns true when data directory exists (no CLI)', () => {
+    mockExecSync.mockImplementation(() => { throw new Error('not found'); });
+    existsSyncSpy.mockImplementation((p: fs.PathLike) => {
+      return String(p).includes('.cursor');
+    });
+    expect(detectAgentPresence('cursor')).toBe(true);
+  });
+
+  it('returns false when neither CLI nor dirs found', () => {
+    mockExecSync.mockImplementation(() => { throw new Error('not found'); });
+    existsSyncSpy.mockReturnValue(false);
+    expect(detectAgentPresence('claude-code')).toBe(false);
+  });
+
+  it('returns true when dir found even if CLI fails (gemini-cli)', () => {
+    mockExecSync.mockImplementation(() => { throw new Error('not found'); });
+    existsSyncSpy.mockImplementation((p: fs.PathLike) => {
+      return String(p).includes('.gemini');
+    });
+    expect(detectAgentPresence('gemini-cli')).toBe(true);
+  });
+
+  it('detects cline via globalStorage dir', () => {
+    existsSyncSpy.mockImplementation((p: fs.PathLike) => {
+      return String(p).includes('saoudrizwan.claude-dev');
+    });
+    expect(detectAgentPresence('cline')).toBe(true);
+  });
+
+  it('detects codebuddy via codebuddy CLI', () => {
+    mockExecSync.mockReturnValue(Buffer.from('/usr/local/bin/codebuddy'));
+    existsSyncSpy.mockReturnValue(false);
+    expect(detectAgentPresence('codebuddy')).toBe(true);
+  });
+
+  it('detects iflow-cli via CLI', () => {
+    mockExecSync.mockReturnValue(Buffer.from('/usr/bin/iflow'));
+    existsSyncSpy.mockReturnValue(false);
+    expect(detectAgentPresence('iflow-cli')).toBe(true);
+  });
+
+  it('detects augment via dir', () => {
+    mockExecSync.mockImplementation(() => { throw new Error('not found'); });
+    existsSyncSpy.mockImplementation((p: fs.PathLike) => {
+      return String(p).includes('.augment');
+    });
+    expect(detectAgentPresence('augment')).toBe(true);
+  });
+
+  it('detects roo via globalStorage dir', () => {
+    mockExecSync.mockImplementation(() => { throw new Error('not found'); });
+    existsSyncSpy.mockImplementation((p: fs.PathLike) => {
+      return String(p).includes('rooveterinaryinc.roo-cline');
+    });
+    expect(detectAgentPresence('roo')).toBe(true);
+  });
+
+  it('detects kimi-cli via CLI', () => {
+    mockExecSync.mockReturnValue(Buffer.from('/usr/bin/kimi'));
+    existsSyncSpy.mockReturnValue(false);
+    expect(detectAgentPresence('kimi-cli')).toBe(true);
+  });
+
+  it('detects qwen-code via dir', () => {
+    mockExecSync.mockImplementation(() => { throw new Error('not found'); });
+    existsSyncSpy.mockImplementation((p: fs.PathLike) => {
+      return String(p).includes('.qwen');
+    });
+    expect(detectAgentPresence('qwen-code')).toBe(true);
+  });
+
+  it('detects qoder via CLI', () => {
+    mockExecSync.mockReturnValue(Buffer.from('/usr/bin/qoder'));
+    existsSyncSpy.mockReturnValue(false);
+    expect(detectAgentPresence('qoder')).toBe(true);
+  });
+
+  it('detects trae-cn via dir', () => {
+    mockExecSync.mockImplementation(() => { throw new Error('not found'); });
+    existsSyncSpy.mockImplementation((p: fs.PathLike) => {
+      return String(p).includes('Trae CN');
+    });
+    expect(detectAgentPresence('trae-cn')).toBe(true);
+  });
+
+  it('detects opencode via CLI', () => {
+    mockExecSync.mockReturnValue(Buffer.from('/usr/bin/opencode'));
+    existsSyncSpy.mockReturnValue(false);
+    expect(detectAgentPresence('opencode')).toBe(true);
+  });
+
+  it('detects pi via CLI', () => {
+    mockExecSync.mockReturnValue(Buffer.from('/usr/bin/pi'));
+    existsSyncSpy.mockReturnValue(false);
+    expect(detectAgentPresence('pi')).toBe(true);
+  });
+
+  it('every agent in MCP_AGENTS has presenceCli or presenceDirs', () => {
+    for (const [key, agent] of Object.entries(MCP_AGENTS)) {
+      const hasCli = !!agent.presenceCli;
+      const hasDirs = Array.isArray(agent.presenceDirs) && agent.presenceDirs.length > 0;
+      expect(hasCli || hasDirs, `${key} missing presenceCli and presenceDirs`).toBe(true);
+    }
+  });
+});

package/_standalone/__tests__/core/errors.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect } from 'vitest';
+import { MindOSError, ErrorCodes, toErrorMessage, apiError, handleRouteError } from '@/lib/errors';
+import type { ApiErrorResponse } from '@/lib/errors';
+
+describe('MindOSError', () => {
+  it('constructs with code and message', () => {
+    const err = new MindOSError(ErrorCodes.FILE_NOT_FOUND, 'not found');
+    expect(err).toBeInstanceOf(Error);
+    expect(err).toBeInstanceOf(MindOSError);
+    expect(err.name).toBe('MindOSError');
+    expect(err.code).toBe('FILE_NOT_FOUND');
+    expect(err.message).toBe('not found');
+    expect(err.context).toBeUndefined();
+    expect(err.userMessage).toBeUndefined();
+  });
+
+  it('constructs with context and userMessage', () => {
+    const err = new MindOSError(
+      ErrorCodes.PATH_OUTSIDE_ROOT,
+      'technical details',
+      { path: '/etc/passwd' },
+      'Access denied',
+    );
+    expect(err.code).toBe('PATH_OUTSIDE_ROOT');
+    expect(err.context).toEqual({ path: '/etc/passwd' });
+    expect(err.userMessage).toBe('Access denied');
+  });
+});
+
+describe('ErrorCodes', () => {
+  it('has all expected codes', () => {
+    const codes = Object.values(ErrorCodes);
+    expect(codes).toContain('FILE_NOT_FOUND');
+    expect(codes).toContain('FILE_ALREADY_EXISTS');
+    expect(codes).toContain('PATH_OUTSIDE_ROOT');
+    expect(codes).toContain('PROTECTED_FILE');
+    expect(codes).toContain('INVALID_PATH');
+    expect(codes).toContain('INVALID_RANGE');
+    expect(codes).toContain('HEADING_NOT_FOUND');
+    expect(codes).toContain('INVALID_FILE_TYPE');
+    expect(codes).toContain('INVALID_REQUEST');
+    expect(codes).toContain('MODEL_INIT_FAILED');
+    expect(codes).toContain('INTERNAL_ERROR');
+    expect(codes).toContain('PERMISSION_DENIED');
+  });
+
+  it('codes are string values matching their keys', () => {
+    for (const [key, value] of Object.entries(ErrorCodes)) {
+      expect(key).toBe(value);
+    }
+  });
+});
+
+describe('toErrorMessage', () => {
+  it('extracts message from Error', () => {
+    expect(toErrorMessage(new Error('oops'))).toBe('oops');
+  });
+
+  it('extracts message from MindOSError', () => {
+    expect(toErrorMessage(new MindOSError(ErrorCodes.FILE_NOT_FOUND, 'gone'))).toBe('gone');
+  });
+
+  it('returns string directly', () => {
+    expect(toErrorMessage('plain string')).toBe('plain string');
+  });
+
+  it('stringifies non-Error/string values', () => {
+    expect(toErrorMessage(42)).toBe('42');
+    expect(toErrorMessage(null)).toBe('null');
+    expect(toErrorMessage(undefined)).toBe('undefined');
+  });
+});
+
+describe('apiError', () => {
+  it('returns NextResponse with structured error body', async () => {
+    const res = apiError(ErrorCodes.FILE_NOT_FOUND, 'gone', 404);
+    expect(res.status).toBe(404);
+    const body = await res.json() as ApiErrorResponse;
+    expect(body.ok).toBe(false);
+    expect(body.error.code).toBe('FILE_NOT_FOUND');
+    expect(body.error.message).toBe('gone');
+  });
+
+  it('derives status from code when not explicitly provided', async () => {
+    const res = apiError(ErrorCodes.FILE_NOT_FOUND, 'gone');
+    expect(res.status).toBe(404);
+
+    const res2 = apiError(ErrorCodes.INVALID_REQUEST, 'bad');
+    expect(res2.status).toBe(400);
+
+    const res3 = apiError(ErrorCodes.PATH_OUTSIDE_ROOT, 'denied');
+    expect(res3.status).toBe(403);
+  });
+});
+
+describe('handleRouteError', () => {
+  it('returns structured response for MindOSError', async () => {
+    const err = new MindOSError(ErrorCodes.PROTECTED_FILE, 'cannot modify');
+    const res = handleRouteError(err);
+    expect(res.status).toBe(403);
+    const body = await res.json() as ApiErrorResponse;
+    expect(body.error.code).toBe('PROTECTED_FILE');
+  });
+
+  it('returns 500 INTERNAL_ERROR for unknown errors', async () => {
+    const res = handleRouteError(new Error('random'));
+    expect(res.status).toBe(500);
+    const body = await res.json() as ApiErrorResponse;
+    expect(body.error.code).toBe('INTERNAL_ERROR');
+    expect(body.error.message).toBe('Internal server error');
+  });
+
+  it('returns 500 INTERNAL_ERROR for non-Error throws', async () => {
+    const res = handleRouteError('string error');
+    expect(res.status).toBe(500);
+    const body = await res.json() as ApiErrorResponse;
+    expect(body.error.code).toBe('INTERNAL_ERROR');
+  });
+});

package/_standalone/__tests__/core/file-convert.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect } from 'vitest';
+import {
+  convertToMarkdown,
+  sanitizeFileName,
+  titleFromFileName,
+  ALLOWED_IMPORT_EXTENSIONS,
+} from '@/lib/core/file-convert';
+
+describe('sanitizeFileName', () => {
+  it('strips path traversal sequences', () => {
+    expect(sanitizeFileName('../../etc/passwd')).not.toContain('..');
+  });
+
+  it('strips leading slashes', () => {
+    expect(sanitizeFileName('/etc/passwd.md')).toBe('passwd.md');
+  });
+
+  it('replaces unsafe characters with dashes', () => {
+    expect(sanitizeFileName('file:name*test?.md')).toBe('file-name-test-.md');
+  });
+
+  it('collapses multiple dashes', () => {
+    expect(sanitizeFileName('a---b.md')).toBe('a-b.md');
+  });
+
+  it('returns fallback for empty input', () => {
+    expect(sanitizeFileName('')).toBe('imported-file');
+  });
+
+  it('preserves emoji and unicode', () => {
+    const result = sanitizeFileName('🎯 Focus.md');
+    expect(result).toContain('🎯');
+    expect(result).toContain('.md');
+  });
+
+  it('handles backslash paths', () => {
+    expect(sanitizeFileName('C:\\Users\\docs\\file.md')).toBe('file.md');
+  });
+});
+
+describe('titleFromFileName', () => {
+  it('derives title from hyphenated filename', () => {
+    expect(titleFromFileName('meeting-notes.md')).toBe('Meeting Notes');
+  });
+
+  it('derives title from underscored filename', () => {
+    expect(titleFromFileName('my_document.txt')).toBe('My Document');
+  });
+
+  it('handles filename without extension', () => {
+    expect(titleFromFileName('readme')).toBe('Readme');
+  });
+
+  it('returns Untitled for truly empty stem', () => {
+    expect(titleFromFileName('')).toBe('Untitled');
+  });
+});
+
+describe('ALLOWED_IMPORT_EXTENSIONS', () => {
+  it('includes all expected extensions', () => {
+    const expected = ['.txt', '.md', '.markdown', '.csv', '.json', '.yaml', '.yml', '.xml', '.html', '.htm', '.pdf'];
+    for (const ext of expected) {
+      expect(ALLOWED_IMPORT_EXTENSIONS.has(ext)).toBe(true);
+    }
+  });
+
+  it('does not include unsupported extensions', () => {
+    expect(ALLOWED_IMPORT_EXTENSIONS.has('.exe')).toBe(false);
+    expect(ALLOWED_IMPORT_EXTENSIONS.has('.zip')).toBe(false);
+  });
+});
+
+describe('convertToMarkdown', () => {
+  it('passes through .md files unchanged', () => {
+    const result = convertToMarkdown('notes.md', '# Hello\n\nContent');
+    expect(result.content).toBe('# Hello\n\nContent');
+    expect(result.targetName).toBe('notes.md');
+    expect(result.originalName).toBe('notes.md');
+  });
+
+  it('passes through .markdown files unchanged', () => {
+    const result = convertToMarkdown('doc.markdown', '# Doc');
+    expect(result.content).toBe('# Doc');
+    expect(result.targetName).toBe('doc.markdown');
+  });
+
+  it('converts .txt to markdown with title', () => {
+    const result = convertToMarkdown('meeting-notes.txt', 'Some text');
+    expect(result.content).toContain('# Meeting Notes');
+    expect(result.content).toContain('Some text');
+    expect(result.targetName).toBe('meeting-notes.md');
+  });
+
+  it('keeps .csv format as-is', () => {
+    const result = convertToMarkdown('data.csv', 'a,b,c\n1,2,3');
+    expect(result.content).toBe('a,b,c\n1,2,3');
+    expect(result.targetName).toBe('data.csv');
+  });
+
+  it('keeps .json format as-is', () => {
+    const result = convertToMarkdown('config.json', '{"key": "value"}');
+    expect(result.content).toBe('{"key": "value"}');
+    expect(result.targetName).toBe('config.json');
+  });
+
+  it('wraps .yaml in code block', () => {
+    const result = convertToMarkdown('config.yaml', 'key: value');
+    expect(result.content).toContain('```yaml');
+    expect(result.content).toContain('key: value');
+    expect(result.targetName).toBe('config.md');
+  });
+
+  it('strips HTML tags from .html files', () => {
+    const result = convertToMarkdown('page.html', '<h1>Hello</h1><p>World</p>');
+    expect(result.content).not.toContain('<h1>');
+    expect(result.content).not.toContain('<p>');
+    expect(result.content).toContain('Hello');
+    expect(result.content).toContain('World');
+    expect(result.targetName).toBe('page.md');
+  });
+
+  it('strips script and style tags from HTML', () => {
+    const html = '<script>alert(1)</script><style>.x{}</style><p>Safe</p>';
+    const result = convertToMarkdown('page.html', html);
+    expect(result.content).not.toContain('alert');
+    expect(result.content).not.toContain('.x{}');
+    expect(result.content).toContain('Safe');
+  });
+
+  it('wraps .xml in code block', () => {
+    const result = convertToMarkdown('data.xml', '<root><item>1</item></root>');
+    expect(result.content).toContain('```xml');
+    expect(result.content).toContain('<root>');
+    expect(result.targetName).toBe('data.md');
+  });
+
+  it('handles unknown extensions as plain text', () => {
+    const result = convertToMarkdown('file.xyz', 'content');
+    expect(result.content).toContain('content');
+    expect(result.targetName).toBe('file.md');
+  });
+
+  it('handles empty content', () => {
+    const result = convertToMarkdown('empty.txt', '');
+    expect(result.content).toContain('# Empty');
+    expect(result.targetName).toBe('empty.md');
+  });
+});

package/_standalone/__tests__/core/fs-ops.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkTempMindRoot, cleanupMindRoot, seedFile, readSeeded } from './helpers';
+import {
+  readFile,
+  writeFile,
+  createFile,
+  deleteFile,
+  renameFile,
+  renameSpaceDirectory,
+} from '@/lib/core/fs-ops';
+import fs from 'fs';
+import path from 'path';
+
+describe('fs-ops', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  describe('readFile', () => {
+    it('reads an existing file', () => {
+      seedFile(mindRoot, 'test.md', 'hello world');
+      expect(readFile(mindRoot, 'test.md')).toBe('hello world');
+    });
+
+    it('reads files in subdirectories', () => {
+      seedFile(mindRoot, 'sub/dir/file.md', 'nested content');
+      expect(readFile(mindRoot, 'sub/dir/file.md')).toBe('nested content');
+    });
+
+    it('throws for non-existent files', () => {
+      expect(() => readFile(mindRoot, 'nope.md')).toThrow();
+    });
+
+    it('throws for path traversal', () => {
+      expect(() => readFile(mindRoot, '../../../etc/passwd')).toThrow('Access denied');
+    });
+  });
+
+  describe('writeFile', () => {
+    it('writes to an existing file atomically', () => {
+      seedFile(mindRoot, 'test.md', 'old');
+      writeFile(mindRoot, 'test.md', 'new content');
+      expect(readSeeded(mindRoot, 'test.md')).toBe('new content');
+    });
+
+    it('creates parent directories if needed', () => {
+      writeFile(mindRoot, 'new/dir/file.md', 'content');
+      expect(readSeeded(mindRoot, 'new/dir/file.md')).toBe('content');
+    });
+
+    it('no temp file left behind on success', () => {
+      seedFile(mindRoot, 'test.md', 'old');
+      writeFile(mindRoot, 'test.md', 'new');
+      const files = fs.readdirSync(mindRoot);
+      expect(files.filter(f => f.startsWith('.tmp-'))).toHaveLength(0);
+    });
+  });
+
+  describe('createFile', () => {
+    it('creates a new file', () => {
+      createFile(mindRoot, 'new.md', 'initial');
+      expect(readSeeded(mindRoot, 'new.md')).toBe('initial');
+    });
+
+    it('creates parent directories', () => {
+      createFile(mindRoot, 'a/b/c.md', 'deep');
+      expect(readSeeded(mindRoot, 'a/b/c.md')).toBe('deep');
+    });
+
+    it('throws if file already exists', () => {
+      seedFile(mindRoot, 'exists.md', 'content');
+      expect(() => createFile(mindRoot, 'exists.md', 'new')).toThrow('already exists');
+    });
+
+    it('defaults to empty content', () => {
+      createFile(mindRoot, 'empty.md');
+      expect(readSeeded(mindRoot, 'empty.md')).toBe('');
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('deletes an existing file', () => {
+      seedFile(mindRoot, 'del.md', 'bye');
+      deleteFile(mindRoot, 'del.md');
+      expect(fs.existsSync(path.join(mindRoot, 'del.md'))).toBe(false);
+    });
+
+    it('throws for non-existent files', () => {
+      expect(() => deleteFile(mindRoot, 'nope.md')).toThrow('not found');
+    });
+  });
+
+  describe('renameFile', () => {
+    it('renames a file within same directory', () => {
+      seedFile(mindRoot, 'old.md', 'content');
+      const newPath = renameFile(mindRoot, 'old.md', 'new.md');
+      expect(newPath).toBe('new.md');
+      expect(readSeeded(mindRoot, 'new.md')).toBe('content');
+      expect(fs.existsSync(path.join(mindRoot, 'old.md'))).toBe(false);
+    });
+
+    it('renames in subdirectory', () => {
+      seedFile(mindRoot, 'sub/old.md', 'content');
+      const newPath = renameFile(mindRoot, 'sub/old.md', 'renamed.md');
+      expect(newPath).toBe(path.join('sub', 'renamed.md'));
+    });
+
+    it('throws if new name has path separators', () => {
+      seedFile(mindRoot, 'file.md', 'x');
+      expect(() => renameFile(mindRoot, 'file.md', 'sub/file.md')).toThrow('path separators');
+    });
+
+    it('throws if target name already exists', () => {
+      seedFile(mindRoot, 'a.md', 'a');
+      seedFile(mindRoot, 'b.md', 'b');
+      expect(() => renameFile(mindRoot, 'a.md', 'b.md')).toThrow('already exists');
+    });
+  });
+
+  describe('renameSpaceDirectory', () => {
+    it('renames a top-level space directory', () => {
+      fs.mkdirSync(path.join(mindRoot, 'SpaceA'), { recursive: true });
+      seedFile(mindRoot, 'SpaceA/README.md', '# A');
+      const newPath = renameSpaceDirectory(mindRoot, 'SpaceA', 'SpaceB');
+      expect(path.normalize(newPath)).toBe(path.normalize('SpaceB'));
+      expect(fs.existsSync(path.join(mindRoot, 'SpaceB', 'README.md'))).toBe(true);
+      expect(fs.existsSync(path.join(mindRoot, 'SpaceA'))).toBe(false);
+    });
+
+    it('renames nested space under parent', () => {
+      fs.mkdirSync(path.join(mindRoot, 'Parent', 'Child'), { recursive: true });
+      seedFile(mindRoot, 'Parent/Child/README.md', '# c');
+      const newPath = renameSpaceDirectory(mindRoot, 'Parent/Child', 'Kid');
+      expect(path.normalize(newPath)).toBe(path.normalize(path.join('Parent', 'Kid')));
+      expect(fs.existsSync(path.join(mindRoot, 'Parent', 'Kid', 'README.md'))).toBe(true);
+    });
+
+    it('throws if path is not a directory', () => {
+      seedFile(mindRoot, 'only-file.md', 'x');
+      expect(() => renameSpaceDirectory(mindRoot, 'only-file.md', 'Dir')).toThrow('Not a directory');
+    });
+
+    it('throws if new_name contains path separators', () => {
+      fs.mkdirSync(path.join(mindRoot, 'S'), { recursive: true });
+      seedFile(mindRoot, 'S/README.md', 'x');
+      expect(() => renameSpaceDirectory(mindRoot, 'S', 'a/b')).toThrow('path separators');
+    });
+
+    it('throws if target directory already exists', () => {
+      fs.mkdirSync(path.join(mindRoot, 'A'), { recursive: true });
+      fs.mkdirSync(path.join(mindRoot, 'B'), { recursive: true });
+      seedFile(mindRoot, 'A/README.md', 'x');
+      seedFile(mindRoot, 'B/README.md', 'y');
+      expect(() => renameSpaceDirectory(mindRoot, 'A', 'B')).toThrow('already exists');
+    });
+
+    it('throws for empty space path', () => {
+      expect(() => renameSpaceDirectory(mindRoot, '', 'X')).toThrow('Space path');
+    });
+  });
+});