@geminilight/mindos 0.6.39 → 0.6.41

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__/core/inbox.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import { mkTempMindRoot, cleanupMindRoot, seedFile, readSeeded } from './helpers';
+import {
+  INBOX_DIR,
+  ensureInboxSpace,
+  listInboxFiles,
+  saveToInbox,
+} from '@/lib/core/inbox';
+
+describe('ensureInboxSpace', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('creates Inbox directory with INSTRUCTION.md and README.md', () => {
+    const result = ensureInboxSpace(mindRoot);
+    expect(result).toBe(path.resolve(mindRoot, INBOX_DIR));
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'INSTRUCTION.md'))).toBe(true);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'README.md'))).toBe(true);
+  });
+
+  it('is idempotent — calling twice does not overwrite existing files', () => {
+    ensureInboxSpace(mindRoot);
+    const original = readSeeded(mindRoot, `${INBOX_DIR}/INSTRUCTION.md`);
+    seedFile(mindRoot, `${INBOX_DIR}/custom.md`, 'user content');
+    ensureInboxSpace(mindRoot);
+    expect(readSeeded(mindRoot, `${INBOX_DIR}/INSTRUCTION.md`)).toBe(original);
+    expect(readSeeded(mindRoot, `${INBOX_DIR}/custom.md`)).toBe('user content');
+  });
+
+  it('recreates Inbox after user deletes it', () => {
+    ensureInboxSpace(mindRoot);
+    fs.rmSync(path.join(mindRoot, INBOX_DIR), { recursive: true, force: true });
+    ensureInboxSpace(mindRoot);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'INSTRUCTION.md'))).toBe(true);
+  });
+});
+
+describe('listInboxFiles', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('returns empty array when Inbox does not exist', () => {
+    expect(listInboxFiles(mindRoot)).toEqual([]);
+  });
+
+  it('returns empty array when Inbox exists but is empty (only system files)', () => {
+    ensureInboxSpace(mindRoot);
+    expect(listInboxFiles(mindRoot)).toEqual([]);
+  });
+
+  it('lists non-system files with metadata', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/notes.md`, '# Notes');
+    seedFile(mindRoot, `${INBOX_DIR}/data.csv`, 'a,b,c');
+
+    const files = listInboxFiles(mindRoot);
+    expect(files).toHaveLength(2);
+    expect(files.map(f => f.name).sort()).toEqual(['data.csv', 'notes.md']);
+    expect(files[0].size).toBeGreaterThan(0);
+    expect(files[0].modifiedAt).toBeTruthy();
+    expect(typeof files[0].isAging).toBe('boolean');
+  });
+
+  it('excludes system files (INSTRUCTION.md, README.md, dotfiles)', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/.hidden`, 'hidden');
+    seedFile(mindRoot, `${INBOX_DIR}/visible.md`, 'ok');
+
+    const files = listInboxFiles(mindRoot);
+    expect(files).toHaveLength(1);
+    expect(files[0].name).toBe('visible.md');
+  });
+
+  it('sorts by modification time (newest first)', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/old.md`, 'old');
+    const oldPath = path.join(mindRoot, INBOX_DIR, 'old.md');
+    const pastTime = new Date(Date.now() - 86400000);
+    fs.utimesSync(oldPath, pastTime, pastTime);
+
+    seedFile(mindRoot, `${INBOX_DIR}/new.md`, 'new');
+
+    const files = listInboxFiles(mindRoot);
+    expect(files[0].name).toBe('new.md');
+    expect(files[1].name).toBe('old.md');
+  });
+
+  it('marks files older than 7 days as aging', () => {
+    ensureInboxSpace(mindRoot);
+    seedFile(mindRoot, `${INBOX_DIR}/aged.md`, 'old content');
+    const filePath = path.join(mindRoot, INBOX_DIR, 'aged.md');
+    const eightDaysAgo = new Date(Date.now() - 8 * 24 * 60 * 60 * 1000);
+    fs.utimesSync(filePath, eightDaysAgo, eightDaysAgo);
+
+    seedFile(mindRoot, `${INBOX_DIR}/fresh.md`, 'new content');
+
+    const files = listInboxFiles(mindRoot);
+    const aged = files.find(f => f.name === 'aged.md');
+    const fresh = files.find(f => f.name === 'fresh.md');
+    expect(aged?.isAging).toBe(true);
+    expect(fresh?.isAging).toBe(false);
+  });
+
+  it('skips subdirectories', () => {
+    ensureInboxSpace(mindRoot);
+    fs.mkdirSync(path.join(mindRoot, INBOX_DIR, 'subdir'), { recursive: true });
+    seedFile(mindRoot, `${INBOX_DIR}/subdir/nested.md`, 'nested');
+    seedFile(mindRoot, `${INBOX_DIR}/top.md`, 'top');
+
+    const files = listInboxFiles(mindRoot);
+    expect(files).toHaveLength(1);
+    expect(files[0].name).toBe('top.md');
+  });
+});
+
+describe('saveToInbox', () => {
+  let mindRoot: string;
+
+  beforeEach(() => { mindRoot = mkTempMindRoot(); });
+  afterEach(() => { cleanupMindRoot(mindRoot); });
+
+  it('saves a markdown file to Inbox', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'notes.md', content: '# My Notes\n\nSome content' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(result.saved[0].original).toBe('notes.md');
+    expect(result.saved[0].path).toBe('Inbox/notes.md');
+    expect(result.skipped).toHaveLength(0);
+
+    const content = readSeeded(mindRoot, 'Inbox/notes.md');
+    expect(content).toContain('My Notes');
+  });
+
+  it('converts .txt to .md with title heading', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'todo.txt', content: 'Buy milk\nFix bug' },
+    ]);
+
+    expect(result.saved[0].path).toBe('Inbox/todo.md');
+    const content = readSeeded(mindRoot, 'Inbox/todo.md');
+    expect(content).toContain('# Todo');
+    expect(content).toContain('Buy milk');
+  });
+
+  it('handles multiple files at once', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'a.md', content: 'aaa' },
+      { name: 'b.md', content: 'bbb' },
+      { name: 'c.md', content: 'ccc' },
+    ]);
+
+    expect(result.saved).toHaveLength(3);
+    expect(fs.readdirSync(path.join(mindRoot, INBOX_DIR))).toContain('a.md');
+    expect(fs.readdirSync(path.join(mindRoot, INBOX_DIR))).toContain('b.md');
+    expect(fs.readdirSync(path.join(mindRoot, INBOX_DIR))).toContain('c.md');
+  });
+
+  it('deduplicates with -1 suffix on name collision', () => {
+    saveToInbox(mindRoot, [{ name: 'notes.md', content: 'first' }]);
+    const result = saveToInbox(mindRoot, [{ name: 'notes.md', content: 'second' }]);
+
+    expect(result.saved[0].path).toBe('Inbox/notes-1.md');
+    expect(readSeeded(mindRoot, 'Inbox/notes.md')).toContain('first');
+    expect(readSeeded(mindRoot, 'Inbox/notes-1.md')).toContain('second');
+  });
+
+  it('skips unsupported file formats', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'script.exe', content: 'binary' },
+      { name: 'notes.md', content: 'ok' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(result.skipped).toHaveLength(1);
+    expect(result.skipped[0].name).toBe('script.exe');
+    expect(result.skipped[0].reason).toContain('Unsupported');
+  });
+
+  it('skips files with empty or invalid names', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: '', content: 'no name' },
+      { name: 'valid.md', content: 'ok' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(result.skipped).toHaveLength(1);
+  });
+
+  it('skips files with missing or null content', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'no-content.md', content: undefined as unknown as string },
+      { name: 'null-content.md', content: null as unknown as string },
+      { name: 'valid.md', content: 'ok' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(result.skipped).toHaveLength(2);
+    expect(result.skipped[0].reason).toContain('Missing');
+    expect(result.skipped[1].reason).toContain('Missing');
+  });
+
+  it('auto-creates Inbox directory if it was deleted', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: 'rescued.md', content: 'saved!' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'INSTRUCTION.md'))).toBe(true);
+    expect(readSeeded(mindRoot, 'Inbox/rescued.md')).toContain('saved!');
+  });
+
+  it('preserves CSV and JSON files as-is (no markdown conversion)', () => {
+    saveToInbox(mindRoot, [
+      { name: 'data.csv', content: 'a,b,c\n1,2,3' },
+      { name: 'config.json', content: '{"key":"value"}' },
+    ]);
+
+    expect(readSeeded(mindRoot, 'Inbox/data.csv')).toBe('a,b,c\n1,2,3');
+    expect(readSeeded(mindRoot, 'Inbox/config.json')).toBe('{"key":"value"}');
+  });
+
+  it('sanitizes dangerous file names', () => {
+    const result = saveToInbox(mindRoot, [
+      { name: '../../../etc/passwd.md', content: 'hack attempt' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(result.saved[0].path).toContain('Inbox/');
+    expect(result.saved[0].path).not.toContain('..');
+  });
+
+  it('handles base64 encoded content', () => {
+    const originalContent = 'Hello from base64!';
+    const base64 = Buffer.from(originalContent).toString('base64');
+    const result = saveToInbox(mindRoot, [
+      { name: 'encoded.md', content: base64, encoding: 'base64' },
+    ]);
+
+    expect(result.saved).toHaveLength(1);
+    expect(readSeeded(mindRoot, 'Inbox/encoded.md')).toContain('Hello from base64!');
+  });
+});

package/_standalone/__tests__/core/skill-install-logic.test.ts

@@ -33,7 +33,7 @@ const SKILL_AGENT_REGISTRY: Record<string, { mode: 'universal' | 'additional' |
   'qoder': { mode: 'additional', skillAgentName: 'qoder' },
   'trae-cn': { mode: 'additional', skillAgentName: 'trae-cn' },
   'roo': { mode: 'additional', skillAgentName: 'roo' },
-  'vscode': { mode: 'universal' },
+  'github-copilot': { mode: 'universal' },
   'codex': { mode: 'universal' },
 };
 
@@ -217,8 +217,8 @@ describe('CLI skill install — end-to-end scenarios', () => {
     expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos -a qoder -g -y');
   });
 
-  it('S9c: vscode should use universal fallback (no explicit -a vscode)', () => {
-    const cmd = simulate('en', ['vscode']);
+  it('S9c: github-copilot should use universal fallback (no explicit -a)', () => {
+    const cmd = simulate('en', ['github-copilot']);
     expect(cmd).toBe('npx skills add "GeminiLight/MindOS" --skill mindos -a universal -g -y');
   });
 

package/_standalone/__tests__/core/sync-status.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { timeAgo } from '@/components/settings/SyncTab';
 import { getStatusLevel } from '@/components/SyncStatusBar';
-import type { SyncStatus } from '@/components/settings/SyncTab';
+import type { SyncStatus } from '@/components/settings/types';
 
 /* ------------------------------------------------------------------ */
 /*  timeAgo                                                           */