@geminilight/mindos 0.6.73 → 0.6.74

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

@@ -1,135 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// We test apiFetch which uses global fetch — mock it
-const mockFetch = vi.fn();
-vi.stubGlobal('fetch', mockFetch);
-
-import { apiFetch, ApiError } from '@/lib/api';
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  mockFetch.mockReset();
-});
-
-describe('ApiError', () => {
-  it('has correct name and status', () => {
-    const err = new ApiError('Not Found', 404);
-    expect(err.name).toBe('ApiError');
-    expect(err.message).toBe('Not Found');
-    expect(err.status).toBe(404);
-    expect(err).toBeInstanceOf(Error);
-  });
-});
-
-describe('apiFetch', () => {
-  it('returns parsed JSON on success', async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({ data: 'hello' }),
-    });
-    const result = await apiFetch<{ data: string }>('/api/test');
-    expect(result).toEqual({ data: 'hello' });
-    expect(mockFetch).toHaveBeenCalledOnce();
-  });
-
-  it('throws ApiError with error body on non-2xx response', async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 403,
-      json: async () => ({ error: 'Forbidden resource' }),
-    });
-    await expect(apiFetch('/api/test')).rejects.toThrow(ApiError);
-    try {
-      await apiFetch('/api/test');
-    } catch (e) {
-      // mockFetch already consumed, re-mock for second call
-    }
-    // Re-test with fresh mock
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 403,
-      json: async () => ({ error: 'Forbidden resource' }),
-    });
-    try {
-      await apiFetch('/api/test');
-      expect.unreachable();
-    } catch (e) {
-      expect(e).toBeInstanceOf(ApiError);
-      expect((e as ApiError).status).toBe(403);
-      expect((e as ApiError).message).toBe('Forbidden resource');
-    }
-  });
-
-  it('throws ApiError with generic message when error body is not JSON', async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 500,
-      json: async () => { throw new Error('not json'); },
-    });
-    try {
-      await apiFetch('/api/test');
-      expect.unreachable();
-    } catch (e) {
-      expect(e).toBeInstanceOf(ApiError);
-      expect((e as ApiError).status).toBe(500);
-      expect((e as ApiError).message).toContain('500');
-    }
-  });
-
-  it('throws ApiError with generic message when error body has no error field', async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: false,
-      status: 422,
-      json: async () => ({ detail: 'something' }),
-    });
-    try {
-      await apiFetch('/api/test');
-      expect.unreachable();
-    } catch (e) {
-      expect(e).toBeInstanceOf(ApiError);
-      expect((e as ApiError).message).toContain('422');
-    }
-  });
-
-  it('passes fetch options through', async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({}),
-    });
-    await apiFetch('/api/test', {
-      method: 'POST',
-      headers: { 'X-Custom': 'value' },
-      body: JSON.stringify({ key: 'val' }),
-    });
-    const [url, opts] = mockFetch.mock.calls[0];
-    expect(url).toBe('/api/test');
-    expect(opts.method).toBe('POST');
-    expect(opts.headers).toEqual({ 'X-Custom': 'value' });
-  });
-
-  it('works with timeout disabled (timeout=0)', async () => {
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({ ok: true }),
-    });
-    const result = await apiFetch('/api/test', { timeout: 0 });
-    expect(result).toEqual({ ok: true });
-    // signal should be undefined when timeout=0 and no external signal
-    const [, opts] = mockFetch.mock.calls[0];
-    expect(opts.signal).toBeUndefined();
-  });
-
-  it('passes external signal when provided', async () => {
-    const controller = new AbortController();
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => ({ ok: true }),
-    });
-    await apiFetch('/api/test', { timeout: 0, signal: controller.signal });
-    const [, opts] = mockFetch.mock.calls[0];
-    // With signal bridging, fetch receives a new controller's signal (not the original)
-    // but aborting the original should propagate — verify signal exists
-    expect(opts.signal).toBeDefined();
-    expect(opts.signal).toBeInstanceOf(AbortSignal);
-  });
-});

package/_standalone/__tests__/core/atomic-append.test.ts

@@ -1,47 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkTempMindRoot, cleanupMindRoot, seedFile } from './helpers';
-import { appendToFile } from '@/lib/core/lines';
-import { readFile } from '@/lib/core/fs-ops';
-
-describe('appendToFile (atomic append)', () => {
-  let mindRoot: string;
-
-  beforeEach(() => { mindRoot = mkTempMindRoot(); });
-  afterEach(() => { cleanupMindRoot(mindRoot); });
-
-  it('appends to non-empty file with newline separator', () => {
-    seedFile(mindRoot, 'a.md', 'line1');
-    appendToFile(mindRoot, 'a.md', 'line2');
-    expect(readFile(mindRoot, 'a.md')).toBe('line1\nline2');
-  });
-
-  it('appends to file already ending with double newline', () => {
-    seedFile(mindRoot, 'a.md', 'line1\n\n');
-    appendToFile(mindRoot, 'a.md', 'line2');
-    expect(readFile(mindRoot, 'a.md')).toBe('line1\n\nline2');
-  });
-
-  it('appends to empty file without separator', () => {
-    seedFile(mindRoot, 'a.md', '');
-    appendToFile(mindRoot, 'a.md', 'first line');
-    expect(readFile(mindRoot, 'a.md')).toBe('first line');
-  });
-
-  it('handles multiple appends', () => {
-    seedFile(mindRoot, 'a.md', 'A');
-    appendToFile(mindRoot, 'a.md', 'B');
-    appendToFile(mindRoot, 'a.md', 'C');
-    const content = readFile(mindRoot, 'a.md');
-    expect(content).toContain('A');
-    expect(content).toContain('B');
-    expect(content).toContain('C');
-  });
-
-  it('handles CJK content', () => {
-    seedFile(mindRoot, 'a.md', '# 知识库');
-    appendToFile(mindRoot, 'a.md', '新的内容');
-    const content = readFile(mindRoot, 'a.md');
-    expect(content).toContain('知识库');
-    expect(content).toContain('新的内容');
-  });
-});

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

@@ -1,72 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkTempMindRoot, cleanupMindRoot, seedFile } from './helpers';
-import { findBacklinks } from '@/lib/core/backlinks';
-
-describe('backlinks', () => {
-  let mindRoot: string;
-
-  beforeEach(() => {
-    mindRoot = mkTempMindRoot();
-  });
-  afterEach(() => { cleanupMindRoot(mindRoot); });
-
-  it('finds wikilink [[target]] references', () => {
-    seedFile(mindRoot, 'target.md', '# Target');
-    seedFile(mindRoot, 'source.md', 'See [[target]] for details.');
-    const results = findBacklinks(mindRoot, 'target.md');
-    expect(results).toHaveLength(1);
-    expect(results[0].source).toBe('source.md');
-    expect(results[0].context).toContain('[[target]]');
-  });
-
-  it('finds markdown link (target.md) references', () => {
-    seedFile(mindRoot, 'Profile/Identity.md', '# Identity');
-    seedFile(mindRoot, 'index.md', 'Read [my profile](Profile/Identity.md) here.');
-    const results = findBacklinks(mindRoot, 'Profile/Identity.md');
-    expect(results).toHaveLength(1);
-    expect(results[0].source).toBe('index.md');
-  });
-
-  it('finds wikilink with display text [[target|Display]]', () => {
-    seedFile(mindRoot, 'target.md', '# Target');
-    seedFile(mindRoot, 'source.md', 'See [[target|My Target]] for more.');
-    const results = findBacklinks(mindRoot, 'target.md');
-    expect(results).toHaveLength(1);
-  });
-
-  it('finds backtick references', () => {
-    seedFile(mindRoot, 'docs/setup.md', '# Setup');
-    seedFile(mindRoot, 'notes.md', 'Check `docs/setup.md` for instructions.');
-    const results = findBacklinks(mindRoot, 'docs/setup.md');
-    expect(results).toHaveLength(1);
-    expect(results[0].source).toBe('notes.md');
-  });
-
-  it('does not include self-references', () => {
-    seedFile(mindRoot, 'self.md', 'This file references [[self]] itself.');
-    const results = findBacklinks(mindRoot, 'self.md');
-    expect(results).toHaveLength(0);
-  });
-
-  it('returns empty when no backlinks exist', () => {
-    seedFile(mindRoot, 'target.md', '# Target');
-    seedFile(mindRoot, 'other.md', 'No references here.');
-    const results = findBacklinks(mindRoot, 'target.md');
-    expect(results).toHaveLength(0);
-  });
-
-  it('only scans .md files', () => {
-    seedFile(mindRoot, 'target.md', '# Target');
-    seedFile(mindRoot, 'data.csv', 'target,value');
-    const results = findBacklinks(mindRoot, 'target.md');
-    expect(results).toHaveLength(0);
-  });
-
-  it('reports line number and context', () => {
-    seedFile(mindRoot, 'target.md', '# Target');
-    seedFile(mindRoot, 'source.md', 'Line 1\nLine 2 with [[target]]\nLine 3');
-    const results = findBacklinks(mindRoot, 'target.md');
-    expect(results[0].line).toBe(2);
-    expect(results[0].context).toContain('Line 2');
-  });
-});

package/_standalone/__tests__/core/bm25-search.test.ts

@@ -1,78 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkTempMindRoot, cleanupMindRoot, seedFile } from './helpers';
-import { searchFiles } from '@/lib/core/search';
-
-describe('BM25 search scoring', () => {
-  let mindRoot: string;
-
-  beforeEach(() => {
-    mindRoot = mkTempMindRoot();
-  });
-
-  afterEach(() => {
-    cleanupMindRoot(mindRoot);
-  });
-
-  it('ranks rare terms higher than common terms', () => {
-    // "search" appears in all 3 files → low IDF
-    // "CRDT" appears in only 1 file → high IDF
-    seedFile(mindRoot, 'Notes/common.md', 'search is a common search feature for search');
-    seedFile(mindRoot, 'Notes/also-common.md', 'we also implement search functionality');
-    seedFile(mindRoot, 'Notes/rare.md', 'search and CRDT algorithms are interesting');
-
-    const results = searchFiles(mindRoot, 'CRDT');
-    expect(results).toHaveLength(1);
-    expect(results[0].path).toBe('Notes/rare.md');
-  });
-
-  it('scores shorter documents higher when term frequency is equal', () => {
-    // Both have "algorithm" once, but short.md is much shorter → higher density
-    seedFile(mindRoot, 'Notes/short.md', 'The algorithm works well.');
-    seedFile(mindRoot, 'Notes/long.md', 'The algorithm ' + 'uses many words to describe things. '.repeat(50));
-
-    const results = searchFiles(mindRoot, 'algorithm');
-    expect(results.length).toBe(2);
-    expect(results[0].path).toBe('Notes/short.md');
-  });
-
-  it('handles multi-word queries by summing per-term BM25 scores', () => {
-    // "search" is common (in all), "vector" is rare (in 1)
-    seedFile(mindRoot, 'Notes/a.md', 'search for things');
-    seedFile(mindRoot, 'Notes/b.md', 'search with vector embeddings');
-    seedFile(mindRoot, 'Notes/c.md', 'search the knowledge base');
-
-    const results = searchFiles(mindRoot, 'vector search');
-    // b.md should rank first because it has the rare word "vector"
-    expect(results[0].path).toBe('Notes/b.md');
-  });
-
-  it('diminishes returns for repeated terms (saturation)', () => {
-    // File with "search" 20 times should NOT score 20x more than file with it 5 times
-    seedFile(mindRoot, 'Notes/moderate.md', ('search feature. ').repeat(5));
-    seedFile(mindRoot, 'Notes/spammy.md', ('search ').repeat(20));
-    seedFile(mindRoot, 'Notes/filler.md', 'nothing relevant here about databases');
-
-    const results = searchFiles(mindRoot, 'search');
-    expect(results.length).toBe(2);
-    // Both should appear but the spammy one shouldn't dominate excessively
-    const scores = results.map(r => r.score);
-    // Spammy has 4x the occurrences but BM25 saturation means score ratio < 4x
-    if (results[0].path === 'Notes/spammy.md') {
-      expect(scores[0] / scores[1]).toBeLessThan(4);
-    }
-  });
-
-  it('returns zero-score results when IDF is near zero (term in all docs)', () => {
-    // When a term appears in every document, IDF approaches 0
-    // BM25 should still return results but with low scores
-    seedFile(mindRoot, 'Notes/a.md', 'common word here');
-    seedFile(mindRoot, 'Notes/b.md', 'common word there');
-
-    const results = searchFiles(mindRoot, 'common');
-    expect(results.length).toBe(2);
-    // Scores should be very low but not negative
-    for (const r of results) {
-      expect(r.score).toBeGreaterThanOrEqual(0);
-    }
-  });
-});

package/_standalone/__tests__/core/chinese-segmentation.test.ts

@@ -1,69 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkTempMindRoot, cleanupMindRoot, seedFile } from './helpers';
-import { SearchIndex } from '@/lib/core/search-index';
-
-describe('Chinese word segmentation (Intl.Segmenter)', () => {
-  let mindRoot: string;
-  let index: SearchIndex;
-
-  beforeEach(() => {
-    mindRoot = mkTempMindRoot();
-    index = new SearchIndex();
-  });
-
-  afterEach(() => {
-    cleanupMindRoot(mindRoot);
-  });
-
-  it('segments Chinese text into proper words, not bigrams', () => {
-    seedFile(mindRoot, 'notes/ai.md', '# 人工智能\n\n知识管理系统是一种工具。');
-    index.rebuild(mindRoot);
-
-    // "知识管理" should match because Intl.Segmenter produces ["知识", "管理"]
-    // and the file contains both tokens
-    const candidates = index.getCandidates('知识管理');
-    expect(candidates).toContain('notes/ai.md');
-  });
-
-  it('finds files by single Chinese word', () => {
-    seedFile(mindRoot, 'a.md', '人工智能的发展');
-    seedFile(mindRoot, 'b.md', '自然语言处理');
-    index.rebuild(mindRoot);
-
-    const candidates = index.getCandidates('智能');
-    expect(candidates).toContain('a.md');
-  });
-
-  it('finds files by multi-word Chinese query', () => {
-    seedFile(mindRoot, 'a.md', '深度学习是人工智能的重要分支');
-    seedFile(mindRoot, 'b.md', '机器学习算法');
-    index.rebuild(mindRoot);
-
-    // Both should match "学习"
-    const candidates = index.getCandidates('学习');
-    expect(candidates).toContain('a.md');
-    expect(candidates).toContain('b.md');
-  });
-
-  it('does not produce false bigram matches', () => {
-    // With bigrams, "识管" would be a token in "知识管理"
-    // With Intl.Segmenter, "识管" should NOT be a token
-    seedFile(mindRoot, 'a.md', '知识管理系统');
-    index.rebuild(mindRoot);
-
-    const candidates = index.getCandidates('识管');
-    // With proper segmentation, "识管" is not a word boundary,
-    // so it should NOT appear as an indexed token.
-    // However, the file may still be found via single-char unigrams.
-    // The key test is that segmentation improves precision.
-    expect(candidates.length).toBeLessThanOrEqual(1);
-  });
-
-  it('handles mixed Chinese and English', () => {
-    seedFile(mindRoot, 'a.md', 'MindOS 是一款知识管理工具');
-    index.rebuild(mindRoot);
-
-    expect(index.getCandidates('mindos')).toContain('a.md');
-    expect(index.getCandidates('知识')).toContain('a.md');
-  });
-});

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

@@ -1,101 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-/**
- * Tests for config.js getStartMode() and isDaemonMode().
- * Since these functions read from ~/.mindos/config.json,
- * we test the underlying logic by directly exercising
- * the config file parsing.
- */
-
-let tmpDir: string;
-let configPath: string;
-
-beforeEach(() => {
-  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-config-test-'));
-  const mindosDir = path.join(tmpDir, '.mindos');
-  fs.mkdirSync(mindosDir, { recursive: true });
-  configPath = path.join(mindosDir, 'config.json');
-});
-
-afterEach(() => {
-  fs.rmSync(tmpDir, { recursive: true, force: true });
-});
-
-/** Mimics getStartMode logic from bin/lib/config.js */
-function getStartMode(cfgPath: string): string {
-  try {
-    const mode = JSON.parse(fs.readFileSync(cfgPath, 'utf-8')).startMode || 'start';
-    return mode === 'daemon' ? 'start' : mode;
-  } catch {
-    return 'start';
-  }
-}
-
-/** Mimics isDaemonMode logic from bin/lib/config.js */
-function isDaemonMode(cfgPath: string): boolean {
-  try {
-    return JSON.parse(fs.readFileSync(cfgPath, 'utf-8')).startMode === 'daemon';
-  } catch {
-    return false;
-  }
-}
-
-describe('getStartMode', () => {
-  it('returns "start" when no config file exists', () => {
-    expect(getStartMode('/nonexistent/config.json')).toBe('start');
-  });
-
-  it('returns "start" when startMode is not set', () => {
-    fs.writeFileSync(configPath, JSON.stringify({ mindRoot: '/tmp' }));
-    expect(getStartMode(configPath)).toBe('start');
-  });
-
-  it('returns "start" when startMode is "start"', () => {
-    fs.writeFileSync(configPath, JSON.stringify({ startMode: 'start' }));
-    expect(getStartMode(configPath)).toBe('start');
-  });
-
-  it('maps "daemon" to "start"', () => {
-    fs.writeFileSync(configPath, JSON.stringify({ startMode: 'daemon' }));
-    expect(getStartMode(configPath)).toBe('start');
-  });
-
-  it('returns "dev" when startMode is "dev"', () => {
-    fs.writeFileSync(configPath, JSON.stringify({ startMode: 'dev' }));
-    expect(getStartMode(configPath)).toBe('dev');
-  });
-
-  it('returns "start" when config is invalid JSON', () => {
-    fs.writeFileSync(configPath, 'not json');
-    expect(getStartMode(configPath)).toBe('start');
-  });
-});
-
-describe('isDaemonMode', () => {
-  it('returns false when no config exists', () => {
-    expect(isDaemonMode('/nonexistent/config.json')).toBe(false);
-  });
-
-  it('returns false when startMode is "start"', () => {
-    fs.writeFileSync(configPath, JSON.stringify({ startMode: 'start' }));
-    expect(isDaemonMode(configPath)).toBe(false);
-  });
-
-  it('returns true when startMode is "daemon"', () => {
-    fs.writeFileSync(configPath, JSON.stringify({ startMode: 'daemon' }));
-    expect(isDaemonMode(configPath)).toBe(true);
-  });
-
-  it('returns false when startMode is not set', () => {
-    fs.writeFileSync(configPath, JSON.stringify({}));
-    expect(isDaemonMode(configPath)).toBe(false);
-  });
-
-  it('returns false for invalid JSON', () => {
-    fs.writeFileSync(configPath, '{broken');
-    expect(isDaemonMode(configPath)).toBe(false);
-  });
-});

package/_standalone/__tests__/core/content-changes.test.ts

@@ -1,131 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import fs from 'fs';
-import path from 'path';
-import { testMindRoot } from '../setup';
-import {
-  appendContentChange,
-  listContentChanges,
-  getContentChangeSummary,
-  markContentChangesSeen,
-} from '../../lib/core/content-changes';
-
-function changeLogPath(root: string) {
-  return path.join(root, '.mindos', 'change-log.json');
-}
-
-describe('core/content-changes', () => {
-  it('creates .mindos/change-log.json on first append', () => {
-    appendContentChange(testMindRoot, {
-      op: 'save_file',
-      path: 'note.md',
-      source: 'user',
-      before: 'a',
-      after: 'b',
-      summary: 'updated file',
-    });
-
-    expect(fs.existsSync(changeLogPath(testMindRoot))).toBe(true);
-    const raw = fs.readFileSync(changeLogPath(testMindRoot), 'utf-8');
-    const json = JSON.parse(raw) as { events: unknown[] };
-    expect(Array.isArray(json.events)).toBe(true);
-    expect(json.events.length).toBe(1);
-  });
-
-  it('lists latest events first and supports path filter', () => {
-    appendContentChange(testMindRoot, {
-      op: 'save_file',
-      path: 'a.md',
-      source: 'user',
-      before: '1',
-      after: '2',
-      summary: 'a changed',
-    });
-    appendContentChange(testMindRoot, {
-      op: 'save_file',
-      path: 'b.md',
-      source: 'agent',
-      before: 'x',
-      after: 'y',
-      summary: 'b changed',
-    });
-
-    const all = listContentChanges(testMindRoot, { limit: 10 });
-    expect(all.length).toBeGreaterThanOrEqual(2);
-    expect(all[0].ts >= all[1].ts).toBe(true);
-
-    const onlyA = listContentChanges(testMindRoot, { path: 'a.md', limit: 10 });
-    expect(onlyA.every((e) => e.path === 'a.md')).toBe(true);
-  });
-
-  it('computes unread summary and mark seen resets unread', () => {
-    appendContentChange(testMindRoot, {
-      op: 'save_file',
-      path: 'summary.md',
-      source: 'agent',
-      before: '',
-      after: 'new',
-      summary: 'summary changed',
-    });
-    const beforeSeen = getContentChangeSummary(testMindRoot);
-    expect(beforeSeen.unreadCount).toBeGreaterThan(0);
-
-    markContentChangesSeen(testMindRoot);
-    const afterSeen = getContentChangeSummary(testMindRoot);
-    expect(afterSeen.unreadCount).toBe(0);
-  });
-
-  it('imports legacy Agent-Diff.md agent-diff blocks into change-log', () => {
-    const legacyPath = path.join(testMindRoot, 'Agent-Diff.md');
-    fs.writeFileSync(legacyPath, [
-      '# Agent Changes',
-      '```agent-diff',
-      JSON.stringify({
-        ts: '2025-01-15T10:30:00Z',
-        path: 'Profile/Identity.md',
-        tool: 'mindos_write_file',
-        before: '# Identity\n\nName: Alice',
-        after: '# Identity\n\nName: Alice\nRole: Engineer',
-      }, null, 2),
-      '```',
-    ].join('\n'), 'utf-8');
-
-    const events = listContentChanges(testMindRoot, { limit: 10 });
-    expect(events.length).toBe(1);
-    expect(events[0].op).toBe('legacy_agent_diff_import');
-    expect(events[0].path).toBe('Profile/Identity.md');
-    expect(events[0].source).toBe('agent');
-
-    const raw = JSON.parse(fs.readFileSync(changeLogPath(testMindRoot), 'utf-8')) as {
-      legacy?: { agentDiffImportedCount?: number };
-    };
-    expect(raw.legacy?.agentDiffImportedCount).toBe(1);
-    expect(fs.existsSync(legacyPath)).toBe(false);
-  });
-
-  it('imports only new legacy blocks on subsequent reads', () => {
-    const legacyPath = path.join(testMindRoot, 'Agent-Diff.md');
-    const makeBlock = (pathValue: string) => [
-      '```agent-diff',
-      JSON.stringify({
-        ts: '2025-01-15T10:30:00Z',
-        path: pathValue,
-        tool: 'mindos_update_lines',
-        before: 'a',
-        after: 'b',
-      }, null, 2),
-      '```',
-    ].join('\n');
-
-    fs.writeFileSync(legacyPath, `# Agent Changes\n\n${makeBlock('a.md')}\n`, 'utf-8');
-    const first = listContentChanges(testMindRoot, { limit: 10 });
-    expect(first.map((e) => e.path)).toContain('a.md');
-
-    // Re-create legacy file to simulate users adding it again manually.
-    fs.writeFileSync(legacyPath, `# Agent Changes\n\n${makeBlock('a.md')}\n${makeBlock('b.md')}\n`, 'utf-8');
-    const second = listContentChanges(testMindRoot, { limit: 10 });
-    const importedLegacy = second.filter((e) => e.op === 'legacy_agent_diff_import');
-    expect(importedLegacy.length).toBe(2);
-    expect(importedLegacy.map((e) => e.path)).toEqual(expect.arrayContaining(['a.md', 'b.md']));
-    expect(fs.existsSync(legacyPath)).toBe(false);
-  });
-});

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

@@ -1,50 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { estimateStringTokens } from '../../lib/agent/context';
-
-describe('Context estimation', () => {
-  describe('estimateStringTokens', () => {
-    it('estimates ASCII text tokens (~0.25 per char)', () => {
-      const text = 'Hello, this is a test sentence with some words.';
-      const tokens = estimateStringTokens(text);
-      // ~48 chars → ~12 tokens
-      expect(tokens).toBeGreaterThan(5);
-      expect(tokens).toBeLessThan(25);
-    });
-
-    it('estimates CJK text tokens (~1.5 per char)', () => {
-      const text = '你好世界这是测试';
-      const tokens = estimateStringTokens(text);
-      // 8 CJK chars → ~12 tokens
-      expect(tokens).toBeGreaterThan(8);
-      expect(tokens).toBeLessThan(20);
-    });
-
-    it('handles mixed CJK and ASCII', () => {
-      const text = 'Hello 你好 World 世界';
-      const tokens = estimateStringTokens(text);
-      expect(tokens).toBeGreaterThan(5);
-      expect(tokens).toBeLessThan(20);
-    });
-
-    it('returns 0 for empty string', () => {
-      expect(estimateStringTokens('')).toBe(0);
-    });
-
-    it('estimates a typical system prompt size', () => {
-      // Simulate a moderate system prompt
-      const prompt = 'You are a helpful assistant.\n'.repeat(100);
-      const tokens = estimateStringTokens(prompt);
-      // ~2800 chars → ~700 tokens
-      expect(tokens).toBeGreaterThan(500);
-      expect(tokens).toBeLessThan(1000);
-    });
-
-    it('estimates large content (20K chars) reasonably', () => {
-      const large = 'a'.repeat(20_000);
-      const tokens = estimateStringTokens(large);
-      // 20000 ASCII chars → ~5000 tokens
-      expect(tokens).toBeGreaterThanOrEqual(4000);
-      expect(tokens).toBeLessThanOrEqual(6000);
-    });
-  });
-});