@geminilight/mindos 0.6.73 → 0.6.74

package/_standalone/__tests__/core/helpers.ts

@@ -1,35 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-/**
- * Creates a temporary directory to use as MIND_ROOT for testing.
- * Returns the absolute path.
- */
-export function mkTempMindRoot(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'mindos-test-'));
-}
-
-/**
- * Removes a temporary MIND_ROOT directory and all its contents.
- */
-export function cleanupMindRoot(mindRoot: string): void {
-  fs.rmSync(mindRoot, { recursive: true, force: true });
-}
-
-/**
- * Creates a file within the temporary mindRoot with the given content.
- * Creates parent directories as needed.
- */
-export function seedFile(mindRoot: string, relativePath: string, content: string): void {
-  const abs = path.join(mindRoot, relativePath);
-  fs.mkdirSync(path.dirname(abs), { recursive: true });
-  fs.writeFileSync(abs, content, 'utf-8');
-}
-
-/**
- * Reads a file from the temporary mindRoot.
- */
-export function readSeeded(mindRoot: string, relativePath: string): string {
-  return fs.readFileSync(path.join(mindRoot, relativePath), 'utf-8');
-}

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

@@ -1,109 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// ── Test the cosine similarity math ──
-import { cosineSimilarity } from '@/lib/core/embedding-index';
-
-describe('cosineSimilarity', () => {
-  it('returns 1 for identical vectors', () => {
-    const a = new Float32Array([1, 2, 3]);
-    expect(cosineSimilarity(a, a)).toBeCloseTo(1, 5);
-  });
-
-  it('returns 0 for orthogonal vectors', () => {
-    const a = new Float32Array([1, 0, 0]);
-    const b = new Float32Array([0, 1, 0]);
-    expect(cosineSimilarity(a, b)).toBeCloseTo(0, 5);
-  });
-
-  it('returns close to 1 for similar vectors', () => {
-    const a = new Float32Array([1, 2, 3]);
-    const b = new Float32Array([1.1, 2.1, 3.1]);
-    expect(cosineSimilarity(a, b)).toBeGreaterThan(0.99);
-  });
-
-  it('returns 0 for zero vectors', () => {
-    const a = new Float32Array([0, 0, 0]);
-    const b = new Float32Array([1, 2, 3]);
-    expect(cosineSimilarity(a, b)).toBe(0);
-  });
-
-  it('returns 0 for mismatched dimensions', () => {
-    const a = new Float32Array([1, 2]);
-    const b = new Float32Array([1, 2, 3]);
-    expect(cosineSimilarity(a, b)).toBe(0);
-  });
-
-  it('returns 0 for empty vectors', () => {
-    const a = new Float32Array([]);
-    const b = new Float32Array([]);
-    expect(cosineSimilarity(a, b)).toBe(0);
-  });
-
-  it('clamps result to [0,1]', () => {
-    // Normalized embedding vectors should naturally stay in [0,1]
-    const a = new Float32Array([0.5, 0.5, 0.5]);
-    const b = new Float32Array([0.5, 0.5, 0.5]);
-    const sim = cosineSimilarity(a, b);
-    expect(sim).toBeGreaterThanOrEqual(0);
-    expect(sim).toBeLessThanOrEqual(1);
-  });
-});
-
-// ── Test hybrid search fallback behavior ──
-// We mock the dependencies to test the RRF merge logic and fallback paths
-
-describe('hybridSearch', () => {
-  // Reset modules between tests to clear singleton state
-  beforeEach(() => {
-    vi.resetModules();
-  });
-
-  it('falls back to pure BM25 when embedding is disabled', async () => {
-    // Mock settings to have embedding disabled
-    vi.doMock('@/lib/settings', () => ({
-      readSettings: () => ({
-        ai: { activeProvider: '', providers: [] },
-        embedding: undefined,
-        mindRoot: '/tmp/test-mind',
-      }),
-      effectiveSopRoot: () => '/tmp/test-mind',
-    }));
-
-    // Mock BM25 search
-    vi.doMock('@/lib/core/search', () => ({
-      searchFiles: () => [
-        { path: 'test.md', snippet: 'test content', score: 10, occurrences: 1 },
-      ],
-    }));
-
-    const { hybridSearch } = await import('@/lib/core/hybrid-search');
-    const results = await hybridSearch('/tmp/test-mind', 'test query');
-    expect(results).toHaveLength(1);
-    expect(results[0].path).toBe('test.md');
-  });
-});
-
-describe('EmbeddingIndex', () => {
-  it('can be instantiated without errors', async () => {
-    const { EmbeddingIndex } = await import('@/lib/core/embedding-index');
-    const index = new EmbeddingIndex();
-    expect(index.isReady()).toBe(false);
-    expect(index.isBuilding()).toBe(false);
-    expect(index.getDocCount()).toBe(0);
-  });
-
-  it('searchByVector returns empty when not ready', async () => {
-    const { EmbeddingIndex } = await import('@/lib/core/embedding-index');
-    const index = new EmbeddingIndex();
-    const results = index.searchByVector(new Float32Array([1, 2, 3]));
-    expect(results).toEqual([]);
-  });
-
-  it('invalidate clears state', async () => {
-    const { EmbeddingIndex } = await import('@/lib/core/embedding-index');
-    const index = new EmbeddingIndex();
-    index.invalidate();
-    expect(index.isReady()).toBe(false);
-    expect(index.getDocCount()).toBe(0);
-  });
-});

package/_standalone/__tests__/core/inbox-url-utils.test.ts

@@ -1,37 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { looksLikeUrl } from '@/lib/inbox-upload';
-
-describe('looksLikeUrl', () => {
-  it('accepts valid http URLs', () => {
-    expect(looksLikeUrl('http://example.com')).toBe(true);
-    expect(looksLikeUrl('http://example.com/path?q=1&a=2')).toBe(true);
-  });
-
-  it('accepts valid https URLs', () => {
-    expect(looksLikeUrl('https://example.com')).toBe(true);
-    expect(looksLikeUrl('https://sub.example.com/long/path#anchor')).toBe(true);
-  });
-
-  it('accepts URLs with leading/trailing whitespace', () => {
-    expect(looksLikeUrl('  https://example.com  ')).toBe(true);
-    expect(looksLikeUrl('\nhttps://example.com\n')).toBe(true);
-  });
-
-  it('rejects non-http schemes', () => {
-    expect(looksLikeUrl('ftp://example.com')).toBe(false);
-    expect(looksLikeUrl('file:///etc/passwd')).toBe(false);
-    expect(looksLikeUrl('javascript:alert(1)')).toBe(false);
-  });
-
-  it('rejects plain text', () => {
-    expect(looksLikeUrl('hello world')).toBe(false);
-    expect(looksLikeUrl('example.com')).toBe(false);
-    expect(looksLikeUrl('')).toBe(false);
-    expect(looksLikeUrl('   ')).toBe(false);
-  });
-
-  it('rejects strings that start with http but are invalid', () => {
-    expect(looksLikeUrl('http://')).toBe(false);
-    expect(looksLikeUrl('https://')).toBe(false);
-  });
-});

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

@@ -1,418 +0,0 @@
-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,
-  deleteFromInbox,
-  archiveFromInbox,
-  listProcessedFiles,
-} 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!');
-  });
-});
-
-describe('deleteFromInbox', () => {
-  let mindRoot: string;
-
-  beforeEach(() => { mindRoot = mkTempMindRoot(); });
-  afterEach(() => { cleanupMindRoot(mindRoot); });
-
-  it('deletes existing files by name', () => {
-    ensureInboxSpace(mindRoot);
-    seedFile(mindRoot, `${INBOX_DIR}/a.md`, 'aaa');
-    seedFile(mindRoot, `${INBOX_DIR}/b.md`, 'bbb');
-
-    const result = deleteFromInbox(mindRoot, ['a.md', 'b.md']);
-    expect(result.deleted).toEqual(['a.md', 'b.md']);
-    expect(result.notFound).toEqual([]);
-    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'a.md'))).toBe(false);
-    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'b.md'))).toBe(false);
-  });
-
-  it('reports not-found for missing files', () => {
-    ensureInboxSpace(mindRoot);
-    const result = deleteFromInbox(mindRoot, ['nonexistent.md']);
-    expect(result.deleted).toEqual([]);
-    expect(result.notFound).toEqual(['nonexistent.md']);
-  });
-
-  it('refuses to delete system files', () => {
-    ensureInboxSpace(mindRoot);
-    const result = deleteFromInbox(mindRoot, ['INSTRUCTION.md', 'README.md']);
-    expect(result.deleted).toEqual([]);
-    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('handles mixed existing and missing files', () => {
-    ensureInboxSpace(mindRoot);
-    seedFile(mindRoot, `${INBOX_DIR}/real.md`, 'content');
-
-    const result = deleteFromInbox(mindRoot, ['real.md', 'fake.md']);
-    expect(result.deleted).toEqual(['real.md']);
-    expect(result.notFound).toEqual(['fake.md']);
-  });
-
-  it('ignores empty or invalid names', () => {
-    ensureInboxSpace(mindRoot);
-    const result = deleteFromInbox(mindRoot, ['', null as unknown as string]);
-    expect(result.deleted).toEqual([]);
-    expect(result.notFound).toEqual([]);
-  });
-
-  it('prevents path traversal attempts', () => {
-    ensureInboxSpace(mindRoot);
-    seedFile(mindRoot, 'outside.md', 'should not be deleted');
-
-    const result = deleteFromInbox(mindRoot, ['../outside.md']);
-    expect(result.notFound).toEqual(['../outside.md']);
-    expect(fs.existsSync(path.join(mindRoot, 'outside.md'))).toBe(true);
-  });
-});
-
-describe('archiveFromInbox', () => {
-  let mindRoot: string;
-
-  beforeEach(() => { mindRoot = mkTempMindRoot(); });
-  afterEach(() => { cleanupMindRoot(mindRoot); });
-
-  it('moves files to .processed/ with timestamp prefix', () => {
-    ensureInboxSpace(mindRoot);
-    seedFile(mindRoot, `${INBOX_DIR}/notes.md`, '# Notes');
-
-    const result = archiveFromInbox(mindRoot, ['notes.md']);
-    expect(result.archived).toHaveLength(1);
-    expect(result.archived[0].original).toBe('notes.md');
-    expect(result.archived[0].archivedPath).toMatch(/^Inbox\/\.processed\/\d{8}-\d{6}_notes\.md$/);
-    expect(result.notFound).toEqual([]);
-
-    expect(fs.existsSync(path.join(mindRoot, INBOX_DIR, 'notes.md'))).toBe(false);
-
-    const processedDir = path.join(mindRoot, INBOX_DIR, '.processed');
-    const processedFiles = fs.readdirSync(processedDir);
-    expect(processedFiles).toHaveLength(1);
-    expect(processedFiles[0]).toMatch(/^\d{8}-\d{6}_notes\.md$/);
-
-    const content = fs.readFileSync(path.join(processedDir, processedFiles[0]), 'utf-8');
-    expect(content).toBe('# Notes');
-  });
-
-  it('reports not-found for missing files', () => {
-    ensureInboxSpace(mindRoot);
-    const result = archiveFromInbox(mindRoot, ['nonexistent.md']);
-    expect(result.archived).toEqual([]);
-    expect(result.notFound).toEqual(['nonexistent.md']);
-  });
-
-  it('refuses to archive system files', () => {
-    ensureInboxSpace(mindRoot);
-    const result = archiveFromInbox(mindRoot, ['INSTRUCTION.md', 'README.md']);
-    expect(result.archived).toEqual([]);
-    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('handles mixed existing and missing files', () => {
-    ensureInboxSpace(mindRoot);
-    seedFile(mindRoot, `${INBOX_DIR}/real.md`, 'content');
-
-    const result = archiveFromInbox(mindRoot, ['real.md', 'fake.md']);
-    expect(result.archived).toHaveLength(1);
-    expect(result.notFound).toEqual(['fake.md']);
-  });
-
-  it('creates .processed/ directory if it does not exist', () => {
-    ensureInboxSpace(mindRoot);
-    seedFile(mindRoot, `${INBOX_DIR}/a.md`, 'aaa');
-
-    const processedDir = path.join(mindRoot, INBOX_DIR, '.processed');
-    expect(fs.existsSync(processedDir)).toBe(false);
-
-    archiveFromInbox(mindRoot, ['a.md']);
-    expect(fs.existsSync(processedDir)).toBe(true);
-  });
-
-  it('archived files are hidden from listInboxFiles', () => {
-    ensureInboxSpace(mindRoot);
-    seedFile(mindRoot, `${INBOX_DIR}/visible.md`, 'visible');
-
-    expect(listInboxFiles(mindRoot)).toHaveLength(1);
-
-    archiveFromInbox(mindRoot, ['visible.md']);
-
-    expect(listInboxFiles(mindRoot)).toHaveLength(0);
-  });
-});
-
-describe('listProcessedFiles', () => {
-  let mindRoot: string;
-
-  beforeEach(() => { mindRoot = mkTempMindRoot(); });
-  afterEach(() => { cleanupMindRoot(mindRoot); });
-
-  it('returns empty array when .processed/ does not exist', () => {
-    expect(listProcessedFiles(mindRoot)).toEqual([]);
-  });
-
-  it('lists archived files sorted by date', () => {
-    ensureInboxSpace(mindRoot);
-    seedFile(mindRoot, `${INBOX_DIR}/a.md`, 'a');
-    seedFile(mindRoot, `${INBOX_DIR}/b.md`, 'b');
-    archiveFromInbox(mindRoot, ['a.md', 'b.md']);
-
-    const files = listProcessedFiles(mindRoot);
-    expect(files).toHaveLength(2);
-    expect(files[0].originalName).toMatch(/\.(md|csv|json)$/);
-    expect(files[0].path).toContain('.processed/');
-  });
-
-  it('extracts original name by stripping timestamp prefix', () => {
-    ensureInboxSpace(mindRoot);
-    seedFile(mindRoot, `${INBOX_DIR}/report.md`, 'content');
-    archiveFromInbox(mindRoot, ['report.md']);
-
-    const files = listProcessedFiles(mindRoot);
-    expect(files[0].originalName).toBe('report.md');
-  });
-});

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

@@ -1,62 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { signJwt, verifyJwt } from '@/lib/jwt';
-
-describe('signJwt + verifyJwt', () => {
-  const secret = 'test-secret-key-1234';
-
-  it('signs and verifies a simple payload', async () => {
-    const payload = { sub: 'user-123', role: 'admin' };
-    const token = await signJwt(payload, secret);
-
-    expect(typeof token).toBe('string');
-    expect(token.split('.')).toHaveLength(3);
-
-    const verified = await verifyJwt(token, secret);
-    expect(verified).not.toBeNull();
-    expect(verified!.sub).toBe('user-123');
-    expect(verified!.role).toBe('admin');
-  });
-
-  it('returns null for invalid token format', async () => {
-    expect(await verifyJwt('not-a-jwt', secret)).toBeNull();
-    expect(await verifyJwt('a.b', secret)).toBeNull();
-    expect(await verifyJwt('', secret)).toBeNull();
-  });
-
-  it('returns null for wrong secret', async () => {
-    const token = await signJwt({ sub: 'test' }, secret);
-    const verified = await verifyJwt(token, 'wrong-secret');
-    expect(verified).toBeNull();
-  });
-
-  it('returns null for expired token', async () => {
-    const payload = { sub: 'test', exp: Math.floor(Date.now() / 1000) - 3600 };
-    const token = await signJwt(payload, secret);
-    const verified = await verifyJwt(token, secret);
-    expect(verified).toBeNull();
-  });
-
-  it('accepts non-expired token', async () => {
-    const payload = { sub: 'test', exp: Math.floor(Date.now() / 1000) + 3600 };
-    const token = await signJwt(payload, secret);
-    const verified = await verifyJwt(token, secret);
-    expect(verified).not.toBeNull();
-    expect(verified!.sub).toBe('test');
-  });
-
-  it('handles payload with special characters', async () => {
-    const payload = { name: '日本語テスト 🎉', path: '/a/b/c' };
-    const token = await signJwt(payload, secret);
-    const verified = await verifyJwt(token, secret);
-    expect(verified).not.toBeNull();
-    expect(verified!.name).toBe('日本語テスト 🎉');
-    expect(verified!.path).toBe('/a/b/c');
-  });
-
-  it('handles empty payload', async () => {
-    const token = await signJwt({}, secret);
-    const verified = await verifyJwt(token, secret);
-    expect(verified).not.toBeNull();
-    expect(verified).toEqual({});
-  });
-});