@geminilight/mindos 0.6.73 → 0.6.74

package/_standalone/__tests__/core/space-aware-tree.test.ts

@@ -1,162 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkTempMindRoot, cleanupMindRoot, seedFile } from './helpers';
-import fs from 'fs';
-import path from 'path';
-
-describe('space-aware file tree', () => {
-  let mindRoot: string;
-
-  beforeEach(() => { mindRoot = mkTempMindRoot(); });
-  afterEach(() => { cleanupMindRoot(mindRoot); });
-
-  describe('buildFileTree — isSpace detection', () => {
-    it('marks directory with INSTRUCTION.md as isSpace', async () => {
-      seedFile(mindRoot, 'Notes/INSTRUCTION.md', '# Notes Instruction\n\n- Rule 1\n- Rule 2');
-      seedFile(mindRoot, 'Notes/README.md', '# Notes\n\nDescription of notes.');
-      seedFile(mindRoot, 'Notes/file.md', 'content');
-
-      const { buildFileTreeForTest } = await import('@/lib/fs');
-      const tree = buildFileTreeForTest(mindRoot);
-      const notes = tree.find(n => n.name === 'Notes');
-      expect(notes).toBeDefined();
-      expect(notes!.isSpace).toBe(true);
-    });
-
-    it('does not mark directory without INSTRUCTION.md as isSpace', async () => {
-      seedFile(mindRoot, 'Archive/file.md', 'content');
-
-      const { buildFileTreeForTest } = await import('@/lib/fs');
-      const tree = buildFileTreeForTest(mindRoot);
-      const archive = tree.find(n => n.name === 'Archive');
-      expect(archive).toBeDefined();
-      expect(archive!.isSpace).toBeUndefined();
-    });
-
-    it('detects nested spaces (subdirectory with INSTRUCTION.md)', async () => {
-      seedFile(mindRoot, 'Projects/INSTRUCTION.md', '# Projects');
-      seedFile(mindRoot, 'Projects/sub/INSTRUCTION.md', '# Sub');
-      seedFile(mindRoot, 'Projects/sub/file.md', 'content');
-
-      const { buildFileTreeForTest } = await import('@/lib/fs');
-      const tree = buildFileTreeForTest(mindRoot);
-      const projects = tree.find(n => n.name === 'Projects');
-      expect(projects!.isSpace).toBe(true);
-      const sub = projects!.children?.find(n => n.name === 'sub');
-      expect(sub!.isSpace).toBe(true);
-    });
-
-    it('ignores directories in IGNORED_DIRS (.git, node_modules, etc.)', async () => {
-      seedFile(mindRoot, '.git/INSTRUCTION.md', '# Git');
-      seedFile(mindRoot, '.git/file.md', 'content');
-
-      const { buildFileTreeForTest } = await import('@/lib/fs');
-      const tree = buildFileTreeForTest(mindRoot);
-      const git = tree.find(n => n.name === '.git');
-      expect(git).toBeUndefined();
-    });
-  });
-
-  describe('buildSpacePreview', () => {
-    it('extracts body lines from INSTRUCTION.md and README.md', async () => {
-      seedFile(mindRoot, 'Notes/INSTRUCTION.md',
-        '# Notes Instruction\n\n## Goal\n\n- Define rules.\n- Keep structured.\n- Trace changes.\n\n## Boundary\n\n- Root wins.'
-      );
-      seedFile(mindRoot, 'Notes/README.md',
-        '# Notes\n\nPersonal learning notes.\n\n## Structure\n\nSome structure info.'
-      );
-      seedFile(mindRoot, 'Notes/file.md', 'content');
-
-      const { buildFileTreeForTest } = await import('@/lib/fs');
-      const tree = buildFileTreeForTest(mindRoot);
-      const notes = tree.find(n => n.name === 'Notes');
-      expect(notes!.spacePreview).toBeDefined();
-      expect(notes!.spacePreview!.instructionLines).toEqual([
-        '- Define rules.',
-        '- Keep structured.',
-        '- Trace changes.',
-      ]);
-      expect(notes!.spacePreview!.readmeLines).toEqual([
-        'Personal learning notes.',
-        'Some structure info.',
-      ]);
-    });
-
-    it('returns empty arrays when files are empty', async () => {
-      seedFile(mindRoot, 'Empty/INSTRUCTION.md', '');
-      seedFile(mindRoot, 'Empty/README.md', '');
-      seedFile(mindRoot, 'Empty/file.md', 'content');
-
-      const { buildFileTreeForTest } = await import('@/lib/fs');
-      const tree = buildFileTreeForTest(mindRoot);
-      const empty = tree.find(n => n.name === 'Empty');
-      expect(empty!.spacePreview!.instructionLines).toEqual([]);
-      expect(empty!.spacePreview!.readmeLines).toEqual([]);
-    });
-
-    it('returns empty readmeLines when README.md does not exist', async () => {
-      seedFile(mindRoot, 'NoReadme/INSTRUCTION.md', '# Inst\n\n- Rule 1');
-      seedFile(mindRoot, 'NoReadme/file.md', 'content');
-
-      const { buildFileTreeForTest } = await import('@/lib/fs');
-      const tree = buildFileTreeForTest(mindRoot);
-      const noReadme = tree.find(n => n.name === 'NoReadme');
-      expect(noReadme!.spacePreview!.instructionLines).toEqual(['- Rule 1']);
-      expect(noReadme!.spacePreview!.readmeLines).toEqual([]);
-    });
-
-    it('skips headings and blank lines, takes at most 3 body lines', async () => {
-      seedFile(mindRoot, 'Long/INSTRUCTION.md',
-        '# Title\n\n## Section\n\n- Line 1\n- Line 2\n- Line 3\n- Line 4\n- Line 5'
-      );
-      seedFile(mindRoot, 'Long/file.md', 'content');
-
-      const { buildFileTreeForTest } = await import('@/lib/fs');
-      const tree = buildFileTreeForTest(mindRoot);
-      const long = tree.find(n => n.name === 'Long');
-      expect(long!.spacePreview!.instructionLines).toHaveLength(3);
-      expect(long!.spacePreview!.instructionLines).toEqual([
-        '- Line 1',
-        '- Line 2',
-        '- Line 3',
-      ]);
-    });
-
-    it('does not set spacePreview for non-space directories', async () => {
-      seedFile(mindRoot, 'Plain/file.md', 'content');
-
-      const { buildFileTreeForTest } = await import('@/lib/fs');
-      const tree = buildFileTreeForTest(mindRoot);
-      const plain = tree.find(n => n.name === 'Plain');
-      expect(plain!.spacePreview).toBeUndefined();
-    });
-  });
-
-  describe('deleteDirectory', () => {
-    it('recursively deletes a directory and all contents', async () => {
-      seedFile(mindRoot, 'ToDelete/sub/file.md', 'content');
-      seedFile(mindRoot, 'ToDelete/README.md', '# ToDelete');
-      seedFile(mindRoot, 'ToDelete/INSTRUCTION.md', '# Inst');
-
-      const { deleteDirectory } = await import('@/lib/core/fs-ops');
-      deleteDirectory(mindRoot, 'ToDelete');
-      expect(fs.existsSync(path.join(mindRoot, 'ToDelete'))).toBe(false);
-    });
-
-    it('throws for non-existent directory', async () => {
-      const { deleteDirectory } = await import('@/lib/core/fs-ops');
-      expect(() => deleteDirectory(mindRoot, 'NonExistent')).toThrow('not found');
-    });
-
-    it('throws for path traversal attempts', async () => {
-      const { deleteDirectory } = await import('@/lib/core/fs-ops');
-      expect(() => deleteDirectory(mindRoot, '../../../tmp')).toThrow('Access denied');
-    });
-
-    it('throws when target is a file, not a directory', async () => {
-      seedFile(mindRoot, 'file.md', 'content');
-
-      const { deleteDirectory } = await import('@/lib/core/fs-ops');
-      expect(() => deleteDirectory(mindRoot, 'file.md')).toThrow('Not a directory');
-    });
-  });
-});

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

@@ -1,120 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkTempMindRoot, cleanupMindRoot, seedFile, readSeeded } from './helpers';
-import { scaffoldIfNewSpace } from '@/lib/core/space-scaffold';
-import fs from 'fs';
-import path from 'path';
-
-describe('scaffoldIfNewSpace', () => {
-  let mindRoot: string;
-
-  beforeEach(() => { mindRoot = mkTempMindRoot(); });
-  afterEach(() => { cleanupMindRoot(mindRoot); });
-
-  // --- Normal paths ---
-
-  it('creates INSTRUCTION.md and README.md for a new top-level directory', () => {
-    // Pre-create the directory (simulating mkdirSync in createFile)
-    fs.mkdirSync(path.join(mindRoot, 'Learning'), { recursive: true });
-
-    scaffoldIfNewSpace(mindRoot, 'Learning/note.md');
-
-    expect(fs.existsSync(path.join(mindRoot, 'Learning/INSTRUCTION.md'))).toBe(true);
-    expect(fs.existsSync(path.join(mindRoot, 'Learning/README.md'))).toBe(true);
-
-    const instruction = readSeeded(mindRoot, 'Learning/INSTRUCTION.md');
-    expect(instruction).toContain('Learning Instruction Set');
-    expect(instruction).toContain('Root `INSTRUCTION.md`');
-
-    const readme = readSeeded(mindRoot, 'Learning/README.md');
-    expect(readme).toContain('# Learning');
-    expect(readme).toContain('INSTRUCTION.md');
-  });
-
-  it('uses cleaned name for emoji-prefixed directories', () => {
-    fs.mkdirSync(path.join(mindRoot, '📖 Learning'), { recursive: true });
-
-    scaffoldIfNewSpace(mindRoot, '📖 Learning/note.md');
-
-    const instruction = readSeeded(mindRoot, '📖 Learning/INSTRUCTION.md');
-    expect(instruction).toContain('Learning Instruction Set');
-    // Should not contain the emoji in the title
-    expect(instruction).not.toMatch(/^# 📖/m);
-  });
-
-  it('only scaffolds first-level directory for deeply nested paths', () => {
-    fs.mkdirSync(path.join(mindRoot, 'Learning/sub/deep'), { recursive: true });
-
-    scaffoldIfNewSpace(mindRoot, 'Learning/sub/deep/file.md');
-
-    // INSTRUCTION.md should be in Learning/, not in sub/ or deep/
-    expect(fs.existsSync(path.join(mindRoot, 'Learning/INSTRUCTION.md'))).toBe(true);
-    expect(fs.existsSync(path.join(mindRoot, 'Learning/sub/INSTRUCTION.md'))).toBe(false);
-  });
-
-  // --- Idempotency ---
-
-  it('does not overwrite existing INSTRUCTION.md', () => {
-    seedFile(mindRoot, 'Existing/INSTRUCTION.md', '# Custom rules');
-
-    scaffoldIfNewSpace(mindRoot, 'Existing/note.md');
-
-    expect(readSeeded(mindRoot, 'Existing/INSTRUCTION.md')).toBe('# Custom rules');
-  });
-
-  it('creates only INSTRUCTION.md when README.md already exists', () => {
-    seedFile(mindRoot, 'Partial/README.md', '# My custom README');
-
-    scaffoldIfNewSpace(mindRoot, 'Partial/note.md');
-
-    // INSTRUCTION.md should be created
-    expect(fs.existsSync(path.join(mindRoot, 'Partial/INSTRUCTION.md'))).toBe(true);
-    // README.md should NOT be overwritten
-    expect(readSeeded(mindRoot, 'Partial/README.md')).toBe('# My custom README');
-  });
-
-  // --- Skip conditions ---
-
-  it('skips root-level files (no top-level directory)', () => {
-    scaffoldIfNewSpace(mindRoot, 'notes.md');
-
-    // Nothing should be created at root level
-    expect(fs.existsSync(path.join(mindRoot, 'INSTRUCTION.md'))).toBe(false);
-  });
-
-  it('skips hidden directories', () => {
-    fs.mkdirSync(path.join(mindRoot, '.agents/skills'), { recursive: true });
-
-    scaffoldIfNewSpace(mindRoot, '.agents/skills/test.md');
-
-    expect(fs.existsSync(path.join(mindRoot, '.agents/INSTRUCTION.md'))).toBe(false);
-  });
-
-  it('skips empty path', () => {
-    // Should not throw
-    scaffoldIfNewSpace(mindRoot, '');
-  });
-
-  it('skips path with only slashes', () => {
-    scaffoldIfNewSpace(mindRoot, '///');
-    // No crash, no files created
-  });
-
-  // --- Error resilience ---
-
-  it('does not throw even if mindRoot does not exist', () => {
-    // Should silently catch the error
-    expect(() => scaffoldIfNewSpace('/nonexistent/path', 'Learning/note.md')).not.toThrow();
-  });
-
-  it('does not throw on read-only directory', () => {
-    // Create dir then make it read-only (skip on non-POSIX)
-    const dir = path.join(mindRoot, 'ReadOnly');
-    fs.mkdirSync(dir);
-    try {
-      fs.chmodSync(dir, 0o444);
-      expect(() => scaffoldIfNewSpace(mindRoot, 'ReadOnly/note.md')).not.toThrow();
-    } finally {
-      fs.chmodSync(dir, 0o755); // restore for cleanup
-    }
-  });
-});

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

@@ -1,121 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { timeAgo } from '@/components/settings/SyncTab';
-import { getStatusLevel } from '@/components/SyncStatusBar';
-import type { SyncStatus } from '@/components/settings/types';
-
-/* ------------------------------------------------------------------ */
-/*  timeAgo                                                           */
-/* ------------------------------------------------------------------ */
-
-describe('timeAgo', () => {
-  it('returns "never" for null/undefined', () => {
-    expect(timeAgo(null)).toBe('never');
-    expect(timeAgo(undefined)).toBe('never');
-  });
-
-  it('returns "just now" for < 60s ago', () => {
-    const now = new Date().toISOString();
-    expect(timeAgo(now)).toBe('just now');
-  });
-
-  it('returns minutes for < 1h ago', () => {
-    const fiveMinAgo = new Date(Date.now() - 5 * 60_000).toISOString();
-    expect(timeAgo(fiveMinAgo)).toBe('5m ago');
-  });
-
-  it('returns hours for < 24h ago', () => {
-    const twoHoursAgo = new Date(Date.now() - 2 * 3600_000).toISOString();
-    expect(timeAgo(twoHoursAgo)).toBe('2h ago');
-  });
-
-  it('returns days for >= 24h ago', () => {
-    const threeDaysAgo = new Date(Date.now() - 3 * 86400_000).toISOString();
-    expect(timeAgo(threeDaysAgo)).toBe('3d ago');
-  });
-});
-
-/* ------------------------------------------------------------------ */
-/*  getStatusLevel                                                    */
-/* ------------------------------------------------------------------ */
-
-const base: SyncStatus = {
-  enabled: true,
-  provider: 'git',
-  remote: 'origin',
-  branch: 'main',
-  lastSync: new Date().toISOString(),
-  lastPull: null,
-  unpushed: '0',
-  conflicts: [],
-  lastError: null,
-  autoCommitInterval: 30,
-  autoPullInterval: 300,
-};
-
-describe('getStatusLevel', () => {
-  it('returns "syncing" when syncing flag is true, regardless of status', () => {
-    expect(getStatusLevel(null, true)).toBe('syncing');
-    expect(getStatusLevel(base, true)).toBe('syncing');
-    expect(getStatusLevel({ ...base, lastError: 'fail' }, true)).toBe('syncing');
-  });
-
-  it('returns "off" when status is null', () => {
-    expect(getStatusLevel(null, false)).toBe('off');
-  });
-
-  it('returns "off" when sync is not enabled', () => {
-    expect(getStatusLevel({ ...base, enabled: false }, false)).toBe('off');
-  });
-
-  it('returns "error" when lastError is set', () => {
-    expect(getStatusLevel({ ...base, lastError: 'push failed' }, false)).toBe('error');
-  });
-
-  it('error takes priority over conflicts and unpushed', () => {
-    const status: SyncStatus = {
-      ...base,
-      lastError: 'network down',
-      conflicts: [{ file: 'a.md', time: '2026-01-01T00:00:00Z' }],
-      unpushed: '3',
-    };
-    expect(getStatusLevel(status, false)).toBe('error');
-  });
-
-  it('returns "conflicts" when conflicts exist (and no error)', () => {
-    const status: SyncStatus = {
-      ...base,
-      conflicts: [{ file: 'notes.md', time: '2026-01-01T00:00:00Z' }],
-    };
-    expect(getStatusLevel(status, false)).toBe('conflicts');
-  });
-
-  it('conflicts take priority over unpushed', () => {
-    const status: SyncStatus = {
-      ...base,
-      conflicts: [{ file: 'a.md', time: '2026-01-01T00:00:00Z' }],
-      unpushed: '5',
-    };
-    expect(getStatusLevel(status, false)).toBe('conflicts');
-  });
-
-  it('returns "unpushed" when unpushed > 0', () => {
-    expect(getStatusLevel({ ...base, unpushed: '3' }, false)).toBe('unpushed');
-    expect(getStatusLevel({ ...base, unpushed: '1' }, false)).toBe('unpushed');
-  });
-
-  it('returns "synced" when everything is clean', () => {
-    expect(getStatusLevel(base, false)).toBe('synced');
-  });
-
-  it('returns "synced" when unpushed is "0"', () => {
-    expect(getStatusLevel({ ...base, unpushed: '0' }, false)).toBe('synced');
-  });
-
-  it('returns "synced" when unpushed is empty string', () => {
-    expect(getStatusLevel({ ...base, unpushed: '' }, false)).toBe('synced');
-  });
-
-  it('returns "synced" when conflicts is empty array', () => {
-    expect(getStatusLevel({ ...base, conflicts: [] }, false)).toBe('synced');
-  });
-});