@geminilight/mindos 0.6.74 → 0.6.75

package/_standalone/__tests__/cli/file-subcommands.test.ts

@@ -0,0 +1,379 @@
+/**
+ * Tests for new `mindos file` subcommands:
+ * write, append, edit-section, insert-heading, append-csv, backlinks, recent, history
+ *
+ * Tests the pure-logic modules (markdown.js, csv.js) and integration via file.js helpers.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+
+function mkTmp(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-cli-file-'));
+}
+function cleanup(dir: string): void {
+  fs.rmSync(dir, { recursive: true, force: true });
+}
+function seed(root: string, rel: string, content: string): void {
+  const abs = path.join(root, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content, 'utf-8');
+}
+function read(root: string, rel: string): string {
+  return fs.readFileSync(path.join(root, rel), 'utf-8');
+}
+
+// ── Markdown section logic (ported from app/lib/core/lines.ts) ──
+
+function findHeadingIndex(lines: string[], heading: string): number {
+  return lines.findIndex(l => {
+    const trimmed = l.trim();
+    return trimmed === heading || trimmed.replace(/^#+\s*/, '') === heading.replace(/^#+\s*/, '');
+  });
+}
+
+function replaceSection(content: string, heading: string, newBody: string): string {
+  const lines = content.split('\n');
+  const idx = findHeadingIndex(lines, heading);
+  if (idx === -1) return '';
+
+  const headingLevel = (lines[idx].match(/^#+/) ?? [''])[0].length;
+  let sectionEnd = lines.length - 1;
+  for (let i = idx + 1; i < lines.length; i++) {
+    const m = lines[i].match(/^(#+)\s/);
+    if (m && m[1].length <= headingLevel) {
+      sectionEnd = i - 1;
+      break;
+    }
+  }
+  while (sectionEnd > idx && lines[sectionEnd].trim() === '') sectionEnd--;
+
+  const before = lines.slice(0, idx + 1);
+  const after = lines.slice(sectionEnd + 1);
+  return [...before, '', newBody, ...after].join('\n');
+}
+
+function insertAfterHeading(content: string, heading: string, insertion: string): string {
+  const lines = content.split('\n');
+  const idx = findHeadingIndex(lines, heading);
+  if (idx === -1) return '';
+
+  let insertAt = idx + 1;
+  while (insertAt < lines.length && lines[insertAt].trim() === '') insertAt++;
+
+  const before = lines.slice(0, insertAt);
+  const after = lines.slice(insertAt);
+  return [...before, '', insertion, ...after].join('\n');
+}
+
+function escapeCsvRow(row: string[]): string {
+  return row.map(cell => {
+    if (cell.includes(',') || cell.includes('"') || cell.includes('\n')) {
+      return `"${cell.replace(/"/g, '""')}"`;
+    }
+    return cell;
+  }).join(',');
+}
+
+function listHeadings(content: string): string[] {
+  return content.split('\n')
+    .filter(l => /^#{1,6}\s/.test(l))
+    .map(l => l.trim());
+}
+
+// ── Markdown replaceSection tests ──
+
+describe('replaceSection', () => {
+  it('replaces section body between same-level headings', () => {
+    const input = '# Title\n\n## A\n\nOld A content\n\n## B\n\nB content';
+    const result = replaceSection(input, '## A', 'New A content');
+    expect(result).toContain('## A');
+    expect(result).toContain('New A content');
+    expect(result).not.toContain('Old A content');
+    expect(result).toContain('## B');
+    expect(result).toContain('B content');
+  });
+
+  it('replaces last section (no following heading)', () => {
+    const input = '# Title\n\n## A\n\nA content\n\n## B\n\nOld B';
+    const result = replaceSection(input, '## B', 'New B');
+    expect(result).toContain('New B');
+    expect(result).not.toContain('Old B');
+  });
+
+  it('returns empty string when heading not found', () => {
+    const input = '# Title\n\n## A\n\nContent';
+    expect(replaceSection(input, '## Missing', 'x')).toBe('');
+  });
+
+  it('handles heading with extra spaces', () => {
+    const input = '## Status \n\nOld status';
+    const result = replaceSection(input, '## Status', 'New status');
+    expect(result).toContain('New status');
+  });
+
+  it('stops at higher-level heading', () => {
+    const input = '# Title\n\n## A\n\nA stuff\n\n### Sub\n\nSub stuff\n\n## B\n\nB stuff';
+    const result = replaceSection(input, '## A', 'Replaced');
+    expect(result).toContain('Replaced');
+    expect(result).toContain('## B');
+    expect(result).toContain('B stuff');
+    expect(result).not.toContain('A stuff');
+    expect(result).not.toContain('Sub stuff');
+  });
+
+  it('replaces section with empty content', () => {
+    const input = '## A\n\nContent\n\n## B\n\nMore';
+    const result = replaceSection(input, '## A', '');
+    expect(result).toContain('## A');
+    expect(result).not.toContain('Content');
+  });
+});
+
+// ── insertAfterHeading tests ──
+
+describe('insertAfterHeading', () => {
+  it('inserts after heading, before existing content', () => {
+    const input = '## Notes\n\nExisting note';
+    const result = insertAfterHeading(input, '## Notes', 'New note');
+    expect(result).toContain('## Notes');
+    expect(result).toContain('New note');
+    expect(result).toContain('Existing note');
+    const lines = result.split('\n');
+    const notesIdx = lines.findIndex(l => l.includes('## Notes'));
+    const newIdx = lines.findIndex(l => l.includes('New note'));
+    const existIdx = lines.findIndex(l => l.includes('Existing note'));
+    expect(newIdx).toBeGreaterThan(notesIdx);
+    expect(newIdx).toBeLessThan(existIdx);
+  });
+
+  it('returns empty string when heading not found', () => {
+    expect(insertAfterHeading('# Title', '## Missing', 'x')).toBe('');
+  });
+
+  it('inserts at end if heading is last thing', () => {
+    const input = '## Notes';
+    const result = insertAfterHeading(input, '## Notes', 'Added');
+    expect(result).toContain('## Notes');
+    expect(result).toContain('Added');
+  });
+});
+
+// ── CSV escaping tests ──
+
+describe('escapeCsvRow', () => {
+  it('joins simple values', () => {
+    expect(escapeCsvRow(['a', 'b', 'c'])).toBe('a,b,c');
+  });
+
+  it('quotes values containing commas', () => {
+    expect(escapeCsvRow(['a,b', 'c'])).toBe('"a,b",c');
+  });
+
+  it('escapes double quotes', () => {
+    expect(escapeCsvRow(['say "hello"', 'x'])).toBe('"say ""hello""",x');
+  });
+
+  it('quotes values containing newlines', () => {
+    expect(escapeCsvRow(['line1\nline2', 'x'])).toBe('"line1\nline2",x');
+  });
+
+  it('handles empty strings', () => {
+    expect(escapeCsvRow(['', '', ''])).toBe(',,');
+  });
+
+  it('handles single value', () => {
+    expect(escapeCsvRow(['only'])).toBe('only');
+  });
+});
+
+// ── listHeadings tests ──
+
+describe('listHeadings', () => {
+  it('extracts all markdown headings', () => {
+    const input = '# Title\n\nSome text\n\n## A\n\nContent\n\n### Sub\n\n## B';
+    expect(listHeadings(input)).toEqual(['# Title', '## A', '### Sub', '## B']);
+  });
+
+  it('returns empty for no headings', () => {
+    expect(listHeadings('Just text\nMore text')).toEqual([]);
+  });
+
+  it('ignores lines that look like headings inside code blocks', () => {
+    expect(listHeadings('## Real\n\n```\n## Not a heading\n```')).toContain('## Real');
+  });
+});
+
+// ── Backlinks logic tests ──
+
+describe('findBacklinksLocal', () => {
+  let root: string;
+  beforeEach(() => { root = mkTmp(); });
+  afterEach(() => { cleanup(root); });
+
+  function findBacklinksLocal(mindRoot: string, targetPath: string): string[] {
+    const results: string[] = [];
+    const bname = path.basename(targetPath, '.md');
+    const escapedTarget = targetPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedBname = bname.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+    const patterns = [
+      new RegExp(`\\[\\[${escapedBname}(?:[|#][^\\]]*)?\\]\\]`, 'i'),
+      new RegExp(`\\[\\[${escapedTarget}(?:[|#][^\\]]*)?\\]\\]`, 'i'),
+      new RegExp(`\\[[^\\]]+\\]\\(${escapedTarget}(?:#[^)]*)?\\)`, 'i'),
+    ];
+
+    function walk(dir: string): void {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith('.')) continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) { walk(full); continue; }
+        if (!entry.name.endsWith('.md')) continue;
+        const rel = path.relative(mindRoot, full);
+        if (rel === targetPath) continue;
+        const content = fs.readFileSync(full, 'utf-8');
+        if (patterns.some(p => p.test(content))) results.push(rel);
+      }
+    }
+    walk(mindRoot);
+    return results;
+  }
+
+  it('finds wikilink references', () => {
+    seed(root, 'target.md', '# Target');
+    seed(root, 'linker.md', 'See [[target]] for details');
+    expect(findBacklinksLocal(root, 'target.md')).toEqual(['linker.md']);
+  });
+
+  it('finds markdown link references', () => {
+    seed(root, 'notes/plan.md', '# Plan');
+    seed(root, 'index.md', 'Check [the plan](notes/plan.md) here');
+    expect(findBacklinksLocal(root, 'notes/plan.md')).toEqual(['index.md']);
+  });
+
+  it('returns empty when no references', () => {
+    seed(root, 'a.md', '# A');
+    seed(root, 'b.md', '# B - no links');
+    expect(findBacklinksLocal(root, 'a.md')).toEqual([]);
+  });
+
+  it('excludes self-references', () => {
+    seed(root, 'self.md', 'Link to [[self]]');
+    expect(findBacklinksLocal(root, 'self.md')).toEqual([]);
+  });
+});
+
+// ── Recent files logic tests ──
+
+describe('getRecentFiles', () => {
+  let root: string;
+  beforeEach(() => { root = mkTmp(); });
+  afterEach(() => { cleanup(root); });
+
+  function getRecentFiles(mindRoot: string, limit: number): Array<{path: string; mtime: number}> {
+    const results: Array<{path: string; mtime: number}> = [];
+    function walk(dir: string): void {
+      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name.startsWith('.')) continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) { walk(full); continue; }
+        if (!entry.name.endsWith('.md') && !entry.name.endsWith('.csv')) continue;
+        const stat = fs.statSync(full);
+        results.push({ path: path.relative(mindRoot, full), mtime: stat.mtimeMs });
+      }
+    }
+    walk(mindRoot);
+    results.sort((a, b) => b.mtime - a.mtime);
+    return results.slice(0, limit);
+  }
+
+  it('returns files sorted by modification time', () => {
+    seed(root, 'old.md', 'old');
+    const oldTime = Date.now() - 10000;
+    fs.utimesSync(path.join(root, 'old.md'), new Date(oldTime), new Date(oldTime));
+    seed(root, 'new.md', 'new');
+    const result = getRecentFiles(root, 10);
+    expect(result[0].path).toBe('new.md');
+    expect(result[1].path).toBe('old.md');
+  });
+
+  it('respects limit', () => {
+    seed(root, 'a.md', 'a');
+    seed(root, 'b.md', 'b');
+    seed(root, 'c.md', 'c');
+    expect(getRecentFiles(root, 2)).toHaveLength(2);
+  });
+
+  it('returns empty for empty directory', () => {
+    expect(getRecentFiles(root, 10)).toEqual([]);
+  });
+
+  it('skips hidden files', () => {
+    seed(root, '.hidden.md', 'hidden');
+    seed(root, 'visible.md', 'visible');
+    const result = getRecentFiles(root, 10);
+    expect(result).toHaveLength(1);
+    expect(result[0].path).toBe('visible.md');
+  });
+});
+
+// ── Git history tests (integration, requires git) ──
+
+describe('gitHistory', () => {
+  let root: string;
+  let hasGit: boolean;
+
+  beforeEach(() => {
+    root = mkTmp();
+    try {
+      execFileSync('git', ['--version'], { stdio: 'pipe' });
+      hasGit = true;
+    } catch { hasGit = false; }
+  });
+  afterEach(() => { cleanup(root); });
+
+  it('returns git log entries for a file', () => {
+    if (!hasGit) return;
+    execFileSync('git', ['init'], { cwd: root, stdio: 'pipe' });
+    execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: root, stdio: 'pipe' });
+    execFileSync('git', ['config', 'user.name', 'Test'], { cwd: root, stdio: 'pipe' });
+    seed(root, 'test.md', 'v1');
+    execFileSync('git', ['add', '.'], { cwd: root, stdio: 'pipe' });
+    execFileSync('git', ['commit', '-m', 'initial'], { cwd: root, stdio: 'pipe' });
+
+    const output = execFileSync(
+      'git',
+      ['log', '--follow', '--format=%H%x00%aI%x00%s%x00%an', '-n', '10', '--', path.join(root, 'test.md')],
+      { cwd: root, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+    ).trim();
+
+    const entries = output.split('\n').map(line => {
+      const [hash, date, message, author] = line.split('\0');
+      return { hash, date, message, author };
+    });
+
+    expect(entries).toHaveLength(1);
+    expect(entries[0].message).toBe('initial');
+    expect(entries[0].author).toBe('Test');
+  });
+
+  it('returns empty for file with no commits', () => {
+    if (!hasGit) return;
+    execFileSync('git', ['init'], { cwd: root, stdio: 'pipe' });
+    seed(root, 'untracked.md', 'content');
+    let output = '';
+    try {
+      output = execFileSync(
+        'git',
+        ['log', '--follow', '--format=%H%x00%aI%x00%s%x00%an', '-n', '10', '--', path.join(root, 'untracked.md')],
+        { cwd: root, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }
+      ).trim();
+    } catch {
+      output = '';
+    }
+    expect(output).toBe('');
+  });
+});

package/_standalone/__tests__/compile/compile-incremental.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { mkTempMindRoot, cleanupMindRoot, seedFile } from '../core/helpers';
+import { collectChangedFiles } from '@/lib/compile';
+
+vi.mock('@/lib/fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/lib/fs')>();
+  let _mindRoot = '';
+  return {
+    ...actual,
+    getMindRoot: () => _mindRoot,
+    setMindRootForTest: (p: string) => { _mindRoot = p; },
+    collectAllFiles: () => {
+      const results: string[] = [];
+      function walk(dir: string, prefix: string) {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+          const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+          if (entry.isDirectory()) walk(path.join(dir, entry.name), rel);
+          else results.push(rel);
+        }
+      }
+      walk(_mindRoot, '');
+      return results;
+    },
+  };
+});
+
+const { setMindRootForTest } = await import('@/lib/fs') as any;
+
+describe('collectChangedFiles', () => {
+  let mindRoot: string;
+
+  beforeEach(() => {
+    mindRoot = mkTempMindRoot();
+    setMindRootForTest(mindRoot);
+  });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('returns all files when all are newer than timestamp', () => {
+    seedFile(mindRoot, 'Space/INSTRUCTION.md', '# Rules');
+    seedFile(mindRoot, 'Space/file1.md', '# File 1');
+    seedFile(mindRoot, 'Space/file2.md', '# File 2');
+
+    // Use a timestamp from the past
+    const pastTime = new Date(Date.now() - 86400_000).toISOString();
+    const { changed, total } = collectChangedFiles(mindRoot, 'Space', pastTime);
+    expect(changed.length).toBe(2); // file1 + file2 (INSTRUCTION.md excluded)
+    expect(total).toBe(2);
+  });
+
+  it('returns empty when no files changed since timestamp', () => {
+    seedFile(mindRoot, 'Space/INSTRUCTION.md', '# Rules');
+    seedFile(mindRoot, 'Space/old.md', '# Old');
+
+    // Use a future timestamp
+    const futureTime = new Date(Date.now() + 86400_000).toISOString();
+    const { changed, total } = collectChangedFiles(mindRoot, 'Space', futureTime);
+    expect(changed.length).toBe(0);
+    expect(total).toBe(1); // old.md still counted in total
+  });
+
+  it('returns only changed files when some are newer', async () => {
+    seedFile(mindRoot, 'Space/INSTRUCTION.md', '# Rules');
+    seedFile(mindRoot, 'Space/old.md', '# Old file');
+
+    // Set old file mtime to past
+    const oldPath = path.join(mindRoot, 'Space/old.md');
+    const pastTime = new Date(Date.now() - 86400_000);
+    fs.utimesSync(oldPath, pastTime, pastTime);
+
+    // Record the "compile" time as slightly before now
+    const compileTime = new Date(Date.now() - 1000).toISOString();
+
+    // Create a new file after compile time
+    seedFile(mindRoot, 'Space/new.md', '# New file');
+
+    const { changed, total } = collectChangedFiles(mindRoot, 'Space', compileTime);
+    expect(total).toBe(2); // old.md + new.md
+    expect(changed.length).toBe(1);
+    expect(changed[0].name).toBe('new.md');
+  });
+
+  it('excludes INSTRUCTION.md and CONFIG.json from results', () => {
+    seedFile(mindRoot, 'Space/INSTRUCTION.md', '# Rules');
+    seedFile(mindRoot, 'Space/CONFIG.json', '{}');
+    seedFile(mindRoot, 'Space/note.md', '# Note');
+
+    const pastTime = new Date(Date.now() - 86400_000).toISOString();
+    const { changed, total } = collectChangedFiles(mindRoot, 'Space', pastTime);
+    expect(total).toBe(1);
+    expect(changed.length).toBe(1);
+    expect(changed[0].name).toBe('note.md');
+  });
+
+  it('handles Space with no files', () => {
+    seedFile(mindRoot, 'Empty/INSTRUCTION.md', '# Rules');
+    const pastTime = new Date(Date.now() - 86400_000).toISOString();
+    const { changed, total } = collectChangedFiles(mindRoot, 'Empty', pastTime);
+    expect(changed.length).toBe(0);
+    expect(total).toBe(0);
+  });
+});

package/_standalone/__tests__/compile/compile-meta.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import {
+  parseCompileMeta,
+  stripCompileMeta,
+  appendCompileMeta,
+} from '@/lib/compile';
+
+describe('parseCompileMeta', () => {
+  it('parses valid compile metadata comment', () => {
+    const content = '# Hello\n\nSome content\n\n<!-- mindos:compiled 2026-04-10T12:00:00Z files:25 -->\n';
+    const meta = parseCompileMeta(content);
+    expect(meta).toEqual({ timestamp: '2026-04-10T12:00:00Z', fileCount: 25 });
+  });
+
+  it('returns null for content without metadata', () => {
+    const content = '# Hello\n\nNo metadata here.';
+    expect(parseCompileMeta(content)).toBeNull();
+  });
+
+  it('returns null for empty string', () => {
+    expect(parseCompileMeta('')).toBeNull();
+  });
+
+  it('parses metadata with different file counts', () => {
+    const content = '<!-- mindos:compiled 2026-01-01T00:00:00Z files:0 -->';
+    const meta = parseCompileMeta(content);
+    expect(meta).toEqual({ timestamp: '2026-01-01T00:00:00Z', fileCount: 0 });
+  });
+
+  it('parses metadata embedded in content', () => {
+    const content = '# Title\n\nBody text.\n\n## Section\n\nMore text.\n\n<!-- mindos:compiled 2026-04-10T08:30:00.000Z files:42 -->\n';
+    const meta = parseCompileMeta(content);
+    expect(meta).toEqual({ timestamp: '2026-04-10T08:30:00.000Z', fileCount: 42 });
+  });
+});
+
+describe('stripCompileMeta', () => {
+  it('removes trailing compile metadata', () => {
+    const content = '# Hello\n\nContent\n\n<!-- mindos:compiled 2026-04-10T12:00:00Z files:25 -->\n';
+    const result = stripCompileMeta(content);
+    // trimEnd in appendCompileMeta handles trailing whitespace, stripCompileMeta just removes the comment
+    expect(result).not.toContain('mindos:compiled');
+    expect(result.trim()).toBe('# Hello\n\nContent');
+  });
+
+  it('returns content unchanged when no metadata', () => {
+    const content = '# Hello\n\nContent';
+    expect(stripCompileMeta(content)).toBe(content);
+  });
+
+  it('handles empty string', () => {
+    expect(stripCompileMeta('')).toBe('');
+  });
+});
+
+describe('appendCompileMeta', () => {
+  it('appends metadata to clean content', () => {
+    const content = '# Hello\n\nContent';
+    const result = appendCompileMeta(content, { timestamp: '2026-04-10T12:00:00Z', fileCount: 10 });
+    expect(result).toBe('# Hello\n\nContent\n\n<!-- mindos:compiled 2026-04-10T12:00:00Z files:10 -->\n');
+  });
+
+  it('replaces existing metadata', () => {
+    const content = '# Hello\n\nContent\n\n<!-- mindos:compiled 2026-01-01T00:00:00Z files:5 -->\n';
+    const result = appendCompileMeta(content, { timestamp: '2026-04-10T12:00:00Z', fileCount: 20 });
+    expect(result).toBe('# Hello\n\nContent\n\n<!-- mindos:compiled 2026-04-10T12:00:00Z files:20 -->\n');
+  });
+
+  it('handles content with trailing whitespace', () => {
+    const content = '# Hello\n\nContent\n\n  ';
+    const result = appendCompileMeta(content, { timestamp: '2026-04-10T12:00:00Z', fileCount: 3 });
+    expect(result).toContain('<!-- mindos:compiled 2026-04-10T12:00:00Z files:3 -->');
+  });
+});

package/_standalone/__tests__/compile/compile.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkTempMindRoot, cleanupMindRoot, seedFile } from '../core/helpers';
+import { collectSpaceFiles } from '@/lib/compile';
+
+vi.mock('@/lib/fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/lib/fs')>();
+  let _mindRoot = '';
+  return {
+    ...actual,
+    getMindRoot: () => _mindRoot,
+    setMindRootForTest: (p: string) => { _mindRoot = p; },
+    collectAllFiles: () => {
+      const fs = require('fs');
+      const path = require('path');
+      const results: string[] = [];
+      function walk(dir: string, prefix: string) {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+          const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+          if (entry.isDirectory()) walk(path.join(dir, entry.name), rel);
+          else results.push(rel);
+        }
+      }
+      walk(_mindRoot, '');
+      return results;
+    },
+  };
+});
+
+const { setMindRootForTest } = await import('@/lib/fs') as any;
+
+describe('collectSpaceFiles', () => {
+  let mindRoot: string;
+
+  beforeEach(() => {
+    mindRoot = mkTempMindRoot();
+    setMindRootForTest(mindRoot);
+  });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('returns empty for Space with no files', () => {
+    seedFile(mindRoot, 'Research/INSTRUCTION.md', '# Rules');
+    const files = collectSpaceFiles(mindRoot, 'Research');
+    expect(files).toEqual([]);
+  });
+
+  it('collects .md files but excludes INSTRUCTION.md and CONFIG.json', () => {
+    seedFile(mindRoot, 'Research/INSTRUCTION.md', '# Rules');
+    seedFile(mindRoot, 'Research/README.md', '# Overview');
+    seedFile(mindRoot, 'Research/CONFIG.json', '{}');
+    seedFile(mindRoot, 'Research/paper1.md', '# Paper 1\nContent here');
+    seedFile(mindRoot, 'Research/paper2.md', '# Paper 2\nMore content');
+    const files = collectSpaceFiles(mindRoot, 'Research');
+    expect(files.length).toBe(3);
+    const names = files.map(f => f.name).sort();
+    expect(names).toEqual(['README.md', 'paper1.md', 'paper2.md']);
+  });
+
+  it('includes nested files with relative paths', () => {
+    seedFile(mindRoot, 'Research/INSTRUCTION.md', '# Rules');
+    seedFile(mindRoot, 'Research/sub/deep.md', '# Deep');
+    const files = collectSpaceFiles(mindRoot, 'Research');
+    expect(files).toHaveLength(1);
+    expect(files[0].name).toBe('sub/deep.md');
+  });
+
+  it('truncates long file content', () => {
+    const longContent = 'x'.repeat(2000);
+    seedFile(mindRoot, 'Research/INSTRUCTION.md', '# Rules');
+    seedFile(mindRoot, 'Research/big.md', longContent);
+    const files = collectSpaceFiles(mindRoot, 'Research');
+    expect(files[0].preview.length).toBeLessThan(longContent.length);
+    expect(files[0].preview).toContain('...(truncated)');
+  });
+
+  it('respects max file limit', () => {
+    seedFile(mindRoot, 'Huge/INSTRUCTION.md', '# Rules');
+    for (let i = 0; i < 100; i++) {
+      seedFile(mindRoot, `Huge/file${String(i).padStart(3, '0')}.md`, `# File ${i}`);
+    }
+    const files = collectSpaceFiles(mindRoot, 'Huge');
+    expect(files.length).toBeLessThanOrEqual(80);
+  });
+
+  it('includes .csv files', () => {
+    seedFile(mindRoot, 'Data/INSTRUCTION.md', '# Rules');
+    seedFile(mindRoot, 'Data/records.csv', 'name,value\nfoo,1\nbar,2');
+    const files = collectSpaceFiles(mindRoot, 'Data');
+    expect(files).toHaveLength(1);
+    expect(files[0].name).toBe('records.csv');
+  });
+
+  it('handles Space with trailing slash', () => {
+    seedFile(mindRoot, 'Notes/INSTRUCTION.md', '# Rules');
+    seedFile(mindRoot, 'Notes/idea.md', '# Idea');
+    const files = collectSpaceFiles(mindRoot, 'Notes/');
+    expect(files).toHaveLength(1);
+  });
+});