stellavault 0.2.0 → 0.2.1

package/packages/core/tests/export-utils.test.ts

@@ -1,97 +0,0 @@
-// Phase 4a: export-utils 순수 함수 테스트
-
-import { describe, it, expect } from 'vitest';
-
-// export-utils는 graph 패키지에 있지만 순수 함수만 테스트
-// DOM 의존 함수는 통합 테스트로 분리
-
-describe('export-utils filename generation', () => {
-  it('generates screenshot filename with timestamp', () => {
-    // 파일명 패턴 검증: stellavault-screenshot-YYYY-MM-DDTHH-MM-SS.png
-    const pattern = /^stellavault-screenshot-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.png$/;
-    const now = new Date();
-    const ts = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
-    const filename = `stellavault-screenshot-${ts}.png`;
-    expect(filename).toMatch(pattern);
-  });
-
-  it('generates recording filename with webm extension', () => {
-    const pattern = /^stellavault-recording-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.webm$/;
-    const now = new Date();
-    const ts = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
-    const filename = `stellavault-recording-${ts}.webm`;
-    expect(filename).toMatch(pattern);
-  });
-});
-
-describe('LOD thresholds', () => {
-  const UNIVERSE_MIN = 800;
-  const NOTE_MAX = 300;
-
-  it('returns universe level for distance > 800', () => {
-    const dist = 900;
-    const level = dist > UNIVERSE_MIN ? 'universe' : dist < NOTE_MAX ? 'note' : 'constellation';
-    expect(level).toBe('universe');
-  });
-
-  it('returns note level for distance < 300', () => {
-    const dist = 200;
-    const level = dist > UNIVERSE_MIN ? 'universe' : dist < NOTE_MAX ? 'note' : 'constellation';
-    expect(level).toBe('note');
-  });
-
-  it('returns constellation level for distance 300-800', () => {
-    for (const dist of [300, 500, 799]) {
-      const level = dist > UNIVERSE_MIN ? 'universe' : dist < NOTE_MAX ? 'note' : 'constellation';
-      expect(level).toBe('constellation');
-    }
-  });
-
-  it('interpolates constellation opacity correctly', () => {
-    const dist = 550; // middle of 300~800 range
-    const t = (dist - NOTE_MAX) / (UNIVERSE_MIN - NOTE_MAX);
-    expect(t).toBeCloseTo(0.5, 1);
-
-    // At distance 300, t = 0 (no constellation lines)
-    const t300 = (300 - NOTE_MAX) / (UNIVERSE_MIN - NOTE_MAX);
-    expect(t300).toBeCloseTo(0, 1);
-
-    // At distance 800, t = 1 (full constellation lines)
-    const t800 = (800 - NOTE_MAX) / (UNIVERSE_MIN - NOTE_MAX);
-    expect(t800).toBeCloseTo(1, 1);
-  });
-
-  it('node scale ranges from 1 (far) to 3 (close)', () => {
-    const tFar = (800 - NOTE_MAX) / (UNIVERSE_MIN - NOTE_MAX);
-    const scaleFar = 1 + (1 - tFar) * 2;
-    expect(scaleFar).toBeCloseTo(1, 1);
-
-    const tClose = (300 - NOTE_MAX) / (UNIVERSE_MIN - NOTE_MAX);
-    const scaleClose = 1 + (1 - tClose) * 2;
-    expect(scaleClose).toBeCloseTo(3, 1);
-  });
-});
-
-describe('graph-store export state', () => {
-  it('lodLevel accepts valid values', () => {
-    const validLevels = ['universe', 'constellation', 'note'] as const;
-    for (const level of validLevels) {
-      expect(typeof level).toBe('string');
-      expect(validLevels).toContain(level);
-    }
-  });
-
-  it('LOD nodeScale mapping matches design', () => {
-    // Design Ref: §8 — LOD node scale factors
-    const lodScaleMap = { universe: 0.6, constellation: 1.0, note: 1.2 };
-    expect(lodScaleMap.universe).toBeLessThan(lodScaleMap.constellation);
-    expect(lodScaleMap.constellation).toBeLessThan(lodScaleMap.note);
-  });
-
-  it('screenshot resolution capped at 4096', () => {
-    const cap = (v: number) => Math.min(v, 4096);
-    expect(cap(2048)).toBe(2048);
-    expect(cap(8192)).toBe(4096);
-    expect(cap(1024)).toBe(1024);
-  });
-});

package/packages/core/tests/fsrs.test.ts

@@ -1,96 +0,0 @@
-// Phase 4b: FSRS 알고리즘 단위 테스트
-
-import { describe, it, expect } from 'vitest';
-import {
-  computeRetrievability,
-  updateStability,
-  estimateInitialStability,
-  elapsedDays,
-  FSRS_PARAMS,
-} from '../src/intelligence/fsrs.js';
-
-describe('FSRS computeRetrievability', () => {
-  it('returns 1.0 for 0 elapsed days', () => {
-    expect(computeRetrievability(7, 0)).toBe(1.0);
-  });
-
-  it('returns ~0.9 after stability days', () => {
-    // R(S) = (1 + S/(9*S))^(-1) = (1 + 1/9)^(-1) = 0.9
-    const r = computeRetrievability(7, 7);
-    expect(r).toBeCloseTo(0.9, 1);
-  });
-
-  it('decays over time', () => {
-    const r7 = computeRetrievability(7, 7);
-    const r30 = computeRetrievability(7, 30);
-    const r90 = computeRetrievability(7, 90);
-    expect(r7).toBeGreaterThan(r30);
-    expect(r30).toBeGreaterThan(r90);
-  });
-
-  it('higher stability = slower decay', () => {
-    const rLow = computeRetrievability(3, 30);
-    const rHigh = computeRetrievability(30, 30);
-    expect(rHigh).toBeGreaterThan(rLow);
-  });
-
-  it('returns 0 for 0 stability', () => {
-    expect(computeRetrievability(0, 10)).toBe(0.0);
-  });
-
-  it('60 days with default stability gives R < 0.5', () => {
-    // Plan SC-01: 장기 미접근 노트는 감쇠
-    // R(60, S=7) ≈ 0.51, R(90, S=7) ≈ 0.41
-    const r90 = computeRetrievability(FSRS_PARAMS.initialStability, 90);
-    expect(r90).toBeLessThan(0.5);
-  });
-});
-
-describe('FSRS updateStability', () => {
-  it('increases stability on access', () => {
-    const newS = updateStability(7, 5, 0.5);
-    expect(newS).toBeGreaterThan(7);
-  });
-
-  it('increases more when R is low (forgotten but recalled)', () => {
-    const sHighR = updateStability(7, 5, 0.9);
-    const sLowR = updateStability(7, 5, 0.3);
-    expect(sLowR).toBeGreaterThan(sHighR);
-  });
-
-  it('caps at 365 days', () => {
-    const s = updateStability(300, 1, 0.1);
-    expect(s).toBeLessThanOrEqual(365);
-  });
-});
-
-describe('FSRS estimateInitialStability', () => {
-  it('base stability for short notes', () => {
-    const s = estimateInitialStability(100, 0);
-    expect(s).toBeCloseTo(FSRS_PARAMS.initialStability, 0);
-  });
-
-  it('longer notes get higher stability', () => {
-    const sShort = estimateInitialStability(100, 0);
-    const sLong = estimateInitialStability(5000, 0);
-    expect(sLong).toBeGreaterThan(sShort);
-  });
-
-  it('more connections increase stability', () => {
-    const s0 = estimateInitialStability(1000, 0);
-    const s5 = estimateInitialStability(1000, 5);
-    expect(s5).toBeGreaterThan(s0);
-  });
-});
-
-describe('elapsedDays', () => {
-  it('computes correct days', () => {
-    const d = elapsedDays('2026-03-01T00:00:00Z', '2026-03-31T00:00:00Z');
-    expect(d).toBeCloseTo(30, 0);
-  });
-
-  it('returns 0 for same timestamp', () => {
-    const now = new Date().toISOString();
-    expect(elapsedDays(now, now)).toBe(0);
-  });
-});

package/packages/core/tests/gesture-detector.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-// gesture-detector는 graph 패키지에 있으므로 로직만 단위 테스트
-// 핵심 알고리즘: 손가락 수 카운팅 + 핀치 거리 + 흔들기 감지
-
-describe('Gesture Detection Logic', () => {
-  it('5개 손가락 펼침 = rotate', () => {
-    // extended >= 4 → rotate
-    const extended = 5;
-    expect(extended >= 4).toBe(true);
-  });
-
-  it('0개 손가락 = pan', () => {
-    const extended = 0;
-    expect(extended === 0).toBe(true);
-  });
-
-  it('핀치 거리 < 0.06 = zoom', () => {
-    const pinchDistance = 0.04;
-    expect(pinchDistance < 0.06).toBe(true);
-  });
-
-  it('핀치 거리 >= 0.06 = not zoom', () => {
-    const pinchDistance = 0.08;
-    expect(pinchDistance < 0.06).toBe(false);
-  });
-
-  it('1개 손가락 (검지) = select', () => {
-    const extended = 1;
-    const isIndexExtended = true;
-    expect(extended === 1 && isIndexExtended).toBe(true);
-  });
-
-  it('흔들기 감지: 3회 이상 방향 전환', () => {
-    // x 좌표 시퀀스: 좌 → 우 → 좌 → 우
-    const history = [0.3, 0.35, 0.4, 0.35, 0.3, 0.35, 0.4, 0.35, 0.3, 0.35];
-    let dirChanges = 0;
-    for (let i = 2; i < history.length; i++) {
-      const prev = history[i - 1] - history[i - 2];
-      const curr = history[i] - history[i - 1];
-      if (prev * curr < 0 && Math.abs(curr) > 0.005) dirChanges++;
-    }
-    expect(dirChanges).toBeGreaterThanOrEqual(3);
-  });
-});

package/packages/core/tests/graph-data.test.ts

@@ -1,87 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { createSqliteVecStore } from '../src/store/sqlite-vec.js';
-import type { VectorStore } from '../src/store/types.js';
-import { buildGraphData } from '../src/api/graph-data.js';
-
-const DIMS = 4;
-let store: VectorStore;
-
-beforeEach(async () => {
-  store = createSqliteVecStore(':memory:', DIMS);
-  await store.initialize();
-
-  // 3개 문서 삽입
-  for (let i = 0; i < 3; i++) {
-    await store.upsertDocument({
-      id: `doc${i}`, filePath: `folder${i}/test.md`, title: `Doc ${i}`,
-      content: `Content ${i}`, frontmatter: {}, tags: ['test'],
-      lastModified: '2026-01-01', contentHash: `hash${i}`,
-    });
-    await store.upsertChunks([{
-      id: `doc${i}#0`, documentId: `doc${i}`, content: `Content ${i}`,
-      heading: `Doc ${i}`, startLine: 1, endLine: 1, tokenCount: 2,
-      embedding: [i === 0 ? 1 : 0, i === 1 ? 1 : 0, i === 2 ? 1 : 0, 0.5],
-    }]);
-  }
-});
-
-afterEach(async () => { await store.close(); });
-
-describe('buildGraphData', () => {
-  it('semantic 모드: 노드 수 = 문서 수', async () => {
-    const data = await buildGraphData(store, { mode: 'semantic' });
-    expect(data.nodes.length).toBe(3);
-    expect(data.stats.nodeCount).toBe(3);
-  });
-
-  it('노드에 필수 필드 존재', async () => {
-    const data = await buildGraphData(store);
-    const node = data.nodes[0];
-    expect(node.id).toBeDefined();
-    expect(node.label).toBeDefined();
-    expect(node.filePath).toBeDefined();
-    expect(node.clusterId).toBeTypeOf('number');
-    expect(node.size).toBeGreaterThan(0);
-  });
-
-  it('엣지 threshold 이상만 생성', async () => {
-    const data = await buildGraphData(store, { edgeThreshold: 0.99 });
-    // 직교 벡터라 유사도 < 0.99 → 엣지 없음
-    expect(data.edges.length).toBe(0);
-  });
-
-  it('엣지 threshold 낮으면 연결 생성', async () => {
-    const data = await buildGraphData(store, { edgeThreshold: 0.0 });
-    expect(data.edges.length).toBeGreaterThan(0);
-    for (const edge of data.edges) {
-      expect(edge.source).toBeDefined();
-      expect(edge.target).toBeDefined();
-      expect(edge.weight).toBeGreaterThanOrEqual(0);
-    }
-  });
-
-  it('folder 모드: 폴더별 클러스터', async () => {
-    const data = await buildGraphData(store, { mode: 'folder' });
-    expect(data.clusters.length).toBe(3); // folder0, folder1, folder2
-    for (const c of data.clusters) {
-      expect(c.label).toBeDefined();
-      expect(c.nodeCount).toBeGreaterThan(0);
-      expect(c.color).toMatch(/^#/);
-    }
-  });
-
-  it('클러스터에 컬러와 라벨 존재', async () => {
-    const data = await buildGraphData(store);
-    for (const c of data.clusters) {
-      expect(c.color).toMatch(/^#/);
-      expect(c.label.length).toBeGreaterThan(0);
-    }
-  });
-
-  it('stats 정확', async () => {
-    const data = await buildGraphData(store);
-    expect(data.stats.nodeCount).toBe(data.nodes.length);
-    expect(data.stats.edgeCount).toBe(data.edges.length);
-    expect(data.stats.clusterCount).toBe(data.clusters.length);
-  });
-});

package/packages/core/tests/layout.test.ts

@@ -1,83 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-// layout.worker는 브라우저 Web Worker이므로 직접 테스트 불가
-// graph-data의 buildGraphData로 노드 위치/엣지 생성을 간접 검증
-
-import { buildGraphData } from '../src/api/graph-data.js';
-import { createSqliteVecStore } from '../src/store/sqlite-vec.js';
-import type { VectorStore } from '../src/store/types.js';
-
-const DIMS = 4;
-
-async function setup(n: number): Promise<VectorStore> {
-  const store = createSqliteVecStore(':memory:', DIMS);
-  await store.initialize();
-  for (let i = 0; i < n; i++) {
-    const vec = [Math.random(), Math.random(), Math.random(), Math.random()];
-    await store.upsertDocument({
-      id: `d${i}`, filePath: `test/d${i}.md`, title: `Doc ${i}`,
-      content: `Content ${i}`, frontmatter: {}, tags: [],
-      lastModified: '2026-01-01', contentHash: `h${i}`,
-    });
-    await store.upsertChunks([{
-      id: `d${i}#0`, documentId: `d${i}`, content: `Content ${i}`,
-      heading: `Doc ${i}`, startLine: 1, endLine: 1, tokenCount: 2,
-      embedding: vec,
-    }]);
-  }
-  return store;
-}
-
-describe('Graph Layout Data Generation', () => {
-  it('노드 수 = 문서 수', async () => {
-    const store = await setup(10);
-    const data = await buildGraphData(store);
-    expect(data.nodes.length).toBe(10);
-    await store.close();
-  });
-
-  it('엣지 source/target이 유효한 노드 ID', async () => {
-    const store = await setup(10);
-    const data = await buildGraphData(store, { edgeThreshold: 0 });
-    const nodeIds = new Set(data.nodes.map(n => n.id));
-    for (const edge of data.edges) {
-      expect(nodeIds.has(edge.source)).toBe(true);
-      expect(nodeIds.has(edge.target)).toBe(true);
-    }
-    await store.close();
-  });
-
-  it('maxEdgesPerNode 제한 동작', async () => {
-    const store = await setup(10);
-    const data = await buildGraphData(store, { edgeThreshold: 0, maxEdgesPerNode: 2 });
-    // 각 노드의 엣지 수가 maxEdgesPerNode 이하
-    const edgeCounts = new Map<string, number>();
-    for (const e of data.edges) {
-      edgeCounts.set(e.source, (edgeCounts.get(e.source) ?? 0) + 1);
-      edgeCounts.set(e.target, (edgeCounts.get(e.target) ?? 0) + 1);
-    }
-    // 중복 엣지 방지로 실제 카운트는 다를 수 있지만, 합리적 범위
-    for (const count of edgeCounts.values()) {
-      expect(count).toBeLessThanOrEqual(20); // 넉넉한 상한
-    }
-    await store.close();
-  });
-
-  it('노드 size가 양수', async () => {
-    const store = await setup(5);
-    const data = await buildGraphData(store);
-    for (const n of data.nodes) {
-      expect(n.size).toBeGreaterThan(0);
-    }
-    await store.close();
-  });
-
-  it('빈 store → 빈 그래프', async () => {
-    const store = createSqliteVecStore(':memory:', DIMS);
-    await store.initialize();
-    const data = await buildGraphData(store);
-    expect(data.nodes.length).toBe(0);
-    expect(data.edges.length).toBe(0);
-    await store.close();
-  });
-});

package/packages/core/tests/mcp.test.ts

@@ -1,148 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { handleSearch, searchToolDef } from '../src/mcp/tools/search.js';
-import { handleGetDocument, getDocumentToolDef } from '../src/mcp/tools/get-document.js';
-import { handleListTopics, listTopicsToolDef } from '../src/mcp/tools/list-topics.js';
-import { handleGetRelated, getRelatedToolDef } from '../src/mcp/tools/get-related.js';
-import type { VectorStore } from '../src/store/types.js';
-import type { SearchEngine } from '../src/search/index.js';
-import type { Document } from '../src/types/document.js';
-
-// Mock data
-const mockDoc: Document = {
-  id: 'doc1', filePath: 'test.md', title: 'Test Document',
-  content: 'Test content about React patterns',
-  frontmatter: { category: 'tech' }, tags: ['react', 'test'],
-  lastModified: '2026-01-01', contentHash: 'abc123',
-};
-
-function createMockStore(): VectorStore {
-  return {
-    getDocument: async (id: string) => id === 'doc1' ? mockDoc : null,
-    getChunk: async () => null,
-    getTopics: async () => [
-      { topic: 'react', count: 5, recentDocuments: [{ id: 'doc1', title: 'Test' }] },
-      { topic: 'security', count: 3, recentDocuments: [] },
-    ],
-    getStats: async () => ({
-      documentCount: 10, chunkCount: 50, dbSizeBytes: 1024, lastIndexed: '2026-01-01',
-    }),
-    initialize: async () => {},
-    close: async () => {},
-    upsertDocument: async () => {},
-    upsertChunks: async () => {},
-    deleteByDocumentId: async () => {},
-    searchSemantic: async () => [],
-    searchKeyword: async () => [],
-    getAllDocumentHashes: async () => new Map(),
-  } as VectorStore;
-}
-
-function createMockSearchEngine(): SearchEngine {
-  return {
-    search: async ({ query, limit }) => [{
-      chunk: {
-        id: 'doc1#0', documentId: 'doc1', content: 'React patterns content',
-        heading: 'Patterns', startLine: 1, endLine: 3, tokenCount: 5,
-      },
-      document: mockDoc,
-      score: 0.85,
-      highlights: ['React patterns content'],
-    }].slice(0, limit ?? 5),
-  };
-}
-
-describe('MCP Tool Definitions', () => {
-  it('search tool schema 유효', () => {
-    expect(searchToolDef.name).toBe('search');
-    expect(searchToolDef.inputSchema.required).toContain('query');
-    expect(searchToolDef.inputSchema.properties.query).toBeDefined();
-    expect(searchToolDef.inputSchema.properties.limit).toBeDefined();
-    expect(searchToolDef.inputSchema.properties.tags).toBeDefined();
-  });
-
-  it('get-document tool schema 유효', () => {
-    expect(getDocumentToolDef.name).toBe('get-document');
-    expect(getDocumentToolDef.inputSchema.required).toContain('id');
-  });
-
-  it('list-topics tool schema 유효', () => {
-    expect(listTopicsToolDef.name).toBe('list-topics');
-    expect(listTopicsToolDef.inputSchema.properties).toBeDefined();
-  });
-
-  it('get-related tool schema 유효', () => {
-    expect(getRelatedToolDef.name).toBe('get-related');
-    expect(getRelatedToolDef.inputSchema.required).toContain('id');
-  });
-});
-
-describe('handleSearch', () => {
-  it('검색 결과를 올바른 형식으로 반환', async () => {
-    const engine = createMockSearchEngine();
-    const results = await handleSearch(engine, { query: 'React' });
-
-    expect(results.length).toBeGreaterThan(0);
-    const r = results[0];
-    expect(r.title).toBe('Test Document');
-    expect(r.filePath).toBe('test.md');
-    expect(r.heading).toBe('Patterns');
-    expect(r.content).toBe('React patterns content');
-    expect(r.score).toBe(0.85);
-    expect(r.tags).toEqual(['react', 'test']);
-  });
-
-  it('limit 전달', async () => {
-    const engine = createMockSearchEngine();
-    const results = await handleSearch(engine, { query: 'React', limit: 1 });
-    expect(results.length).toBeLessThanOrEqual(1);
-  });
-});
-
-describe('handleGetDocument', () => {
-  it('존재하는 문서 반환', async () => {
-    const store = createMockStore();
-    const result = await handleGetDocument(store, { id: 'doc1' });
-
-    expect(result).not.toHaveProperty('error');
-    expect((result as any).title).toBe('Test Document');
-    expect((result as any).filePath).toBe('test.md');
-    expect((result as any).content).toBe('Test content about React patterns');
-    expect((result as any).tags).toEqual(['react', 'test']);
-  });
-
-  it('존재하지 않는 문서는 error 반환', async () => {
-    const store = createMockStore();
-    const result = await handleGetDocument(store, { id: 'nonexistent' });
-    expect(result).toHaveProperty('error');
-  });
-});
-
-describe('handleListTopics', () => {
-  it('토픽 목록과 통계 반환', async () => {
-    const store = createMockStore();
-    const result = await handleListTopics(store);
-
-    expect(result.topics).toHaveLength(2);
-    expect(result.topics[0].topic).toBe('react');
-    expect(result.totalDocuments).toBe(10);
-    expect(result.totalChunks).toBe(50);
-  });
-});
-
-describe('handleGetRelated', () => {
-  it('관련 문서 반환 (자기 자신 제외)', async () => {
-    const store = createMockStore();
-    const engine = createMockSearchEngine();
-    const results = await handleGetRelated(store, engine, { id: 'doc1' });
-
-    // doc1 자체는 필터링되므로 빈 결과 가능
-    expect(Array.isArray(results)).toBe(true);
-  });
-
-  it('존재하지 않는 문서 ID는 error 반환', async () => {
-    const store = createMockStore();
-    const engine = createMockSearchEngine();
-    const result = await handleGetRelated(store, engine, { id: 'nonexistent' });
-    expect(result).toHaveProperty('error');
-  });
-});

package/packages/core/tests/pack.test.ts

@@ -1,127 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { createSqliteVecStore } from '../src/store/sqlite-vec.js';
-import { createSearchEngine } from '../src/search/index.js';
-import { createPack, exportPack, importPack } from '../src/pack/index.js';
-import type { VectorStore } from '../src/store/types.js';
-import type { Embedder } from '../src/indexer/embedder.js';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { existsSync, unlinkSync } from 'node:fs';
-
-const DIMS = 4;
-let store: VectorStore;
-let embedder: Embedder;
-
-function mockEmbedder(): Embedder {
-  return {
-    dimensions: DIMS, modelName: 'test-model',
-    initialize: async () => {},
-    embed: async (text) => {
-      const h = text.length;
-      return [h % 3 / 3, h % 5 / 5, h % 7 / 7, h % 11 / 11];
-    },
-    embedBatch: async (texts) => texts.map(t => {
-      const h = t.length;
-      return [h % 3 / 3, h % 5 / 5, h % 7 / 7, h % 11 / 11];
-    }),
-  };
-}
-
-beforeEach(async () => {
-  store = createSqliteVecStore(':memory:', DIMS);
-  await store.initialize();
-  embedder = mockEmbedder();
-
-  await store.upsertDocument({
-    id: 'doc1', filePath: '08_Patterns/auth.md', title: 'Auth Pattern',
-    content: 'OAuth patterns for authentication. Contact admin@test.com',
-    frontmatter: {}, tags: ['auth'], lastModified: '2026-01-01', contentHash: 'h1',
-  });
-  await store.upsertChunks([{
-    id: 'doc1#0', documentId: 'doc1',
-    content: 'OAuth patterns for authentication. Contact admin@test.com',
-    heading: 'Auth Pattern', startLine: 1, endLine: 1, tokenCount: 8,
-    embedding: [0.5, 0.5, 0.5, 0.5],
-  }]);
-});
-
-afterEach(async () => { await store.close(); });
-
-describe('Knowledge Pack', () => {
-  it('검색 기반 팩 생성', async () => {
-    const searchEngine = createSearchEngine({ store, embedder });
-    const { pack, piiReport } = await createPack(store, searchEngine, embedder, {
-      name: 'auth-patterns',
-      fromSearch: 'OAuth',
-    });
-
-    expect(pack.name).toBe('auth-patterns');
-    expect(pack.chunks.length).toBeGreaterThan(0);
-    expect(pack.embeddingModel).toBe('test-model');
-    expect(pack.schemaVersion).toBe('1.0');
-  });
-
-  it('PII 자동 마스킹', async () => {
-    const searchEngine = createSearchEngine({ store, embedder });
-    const { pack, piiReport } = await createPack(store, searchEngine, embedder, {
-      name: 'test-pii',
-      fromSearch: 'OAuth',
-    });
-
-    // 이메일이 마스킹되어야 함
-    for (const chunk of pack.chunks) {
-      expect(chunk.content).not.toContain('admin@test.com');
-    }
-    expect(piiReport.redactedCount).toBeGreaterThan(0);
-  });
-
-  it('내보내기 + 가져오기 라운드트립', async () => {
-    const searchEngine = createSearchEngine({ store, embedder });
-    const { pack } = await createPack(store, searchEngine, embedder, {
-      name: 'roundtrip-test',
-      fromSearch: 'OAuth',
-    });
-
-    const tmpPath = join(tmpdir(), 'test-roundtrip.sv-pack');
-    exportPack(pack, tmpPath);
-    expect(existsSync(tmpPath)).toBe(true);
-
-    // 새 store에 import
-    const store2 = createSqliteVecStore(':memory:', DIMS);
-    await store2.initialize();
-
-    const result = await importPack(store2, embedder, tmpPath);
-    expect(result.imported).toBeGreaterThan(0);
-    expect(result.modelMismatch).toBe(false);
-
-    // import된 청크 검색 가능
-    const stats = await store2.getStats();
-    expect(stats.chunkCount).toBeGreaterThan(0);
-
-    await store2.close();
-    try { unlinkSync(tmpPath); } catch {}
-  });
-
-  it('모델 불일치 시 재임베딩', async () => {
-    const searchEngine = createSearchEngine({ store, embedder });
-    const { pack } = await createPack(store, searchEngine, embedder, {
-      name: 'mismatch-test',
-      fromSearch: 'OAuth',
-    });
-
-    const tmpPath = join(tmpdir(), 'test-mismatch.sv-pack');
-    exportPack(pack, tmpPath);
-
-    // 다른 모델명의 embedder로 import
-    const otherEmbedder = { ...mockEmbedder(), modelName: 'other-model' };
-    const store2 = createSqliteVecStore(':memory:', DIMS);
-    await store2.initialize();
-
-    const result = await importPack(store2, otherEmbedder, tmpPath);
-    expect(result.modelMismatch).toBe(true);
-    expect(result.reEmbedded).toBeGreaterThan(0);
-
-    await store2.close();
-    try { unlinkSync(tmpPath); } catch {}
-  });
-});