@geminilight/mindos 0.6.73 → 0.6.74

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

@@ -1,39 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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

@@ -1,162 +0,0 @@
-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');
-    });
-  });
-});