stellavault 0.1.0

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

@@ -0,0 +1,148 @@
+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

@@ -0,0 +1,127 @@
+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 {}
+  });
+});

package/packages/core/tests/pii-masker.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { maskPII } from '../src/pack/pii-masker.js';
+
+describe('PII Masker', () => {
+  it('이메일 마스킹', () => {
+    const { masked, redactedCount } = maskPII('Contact user@example.com for help');
+    expect(masked).not.toContain('user@example.com');
+    expect(masked).toContain('[REDACTED:email]');
+    expect(redactedCount).toBe(1);
+  });
+
+  it('API 키 마스킹', () => {
+    const { masked } = maskPII('Use sk_live_1234567890abcdefghij for auth');
+    expect(masked).toContain('[REDACTED:api_key]');
+  });
+
+  it('AWS 키 마스킹', () => {
+    const { masked } = maskPII('AWS key: AKIAIOSFODNN7EXAMPLE');
+    expect(masked).toContain('[REDACTED:aws_key]');
+  });
+
+  it('JWT 마스킹', () => {
+    const { masked } = maskPII('token: eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U');
+    expect(masked).toContain('[REDACTED:jwt]');
+  });
+
+  it('PII 없으면 변경 없음', () => {
+    const text = 'React 컴포넌트 패턴에 대한 가이드';
+    const { masked, redactedCount } = maskPII(text);
+    expect(masked).toBe(text);
+    expect(redactedCount).toBe(0);
+  });
+
+  it('복수 PII 동시 마스킹', () => {
+    const { masked, redactedCount, redactedTypes } = maskPII(
+      'admin@test.com has key sk_test_abcdefghijklmnopqrstuvwxyz1234'
+    );
+    expect(redactedCount).toBeGreaterThanOrEqual(2);
+    expect(redactedTypes).toContain('email');
+    expect(redactedTypes).toContain('api_key');
+  });
+});

package/packages/core/tests/profile-card.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+
+// profile-card SVG 생성 로직 검증
+// 실제 함수는 graph 패키지이므로 SVG 구조 검증용 단위 테스트
+
+function generateSimpleSVG(data: {
+  documentCount: number;
+  clusterCount: number;
+  edgeCount: number;
+  clusters: Array<{ label: string; nodeCount: number; color: string }>;
+  tags: Array<{ tag: string; count: number }>;
+}): string {
+  const W = 800, H = 420;
+  const esc = (s: string) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;');
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}">
+    <text>${data.documentCount} docs</text>
+    ${data.clusters.map(c => `<circle fill="${c.color}"/>`).join('')}
+    ${data.tags.map(t => `<text>#${esc(t.tag)}</text>`).join('')}
+  </svg>`;
+}
+
+describe('Profile Card SVG', () => {
+  it('유효한 SVG 생성', () => {
+    const svg = generateSimpleSVG({
+      documentCount: 100, clusterCount: 5, edgeCount: 200,
+      clusters: [{ label: 'AI', nodeCount: 50, color: '#6366f1' }],
+      tags: [{ tag: 'react', count: 10 }],
+    });
+    expect(svg).toContain('<svg');
+    expect(svg).toContain('100 docs');
+  });
+
+  it('클러스터 컬러 포함', () => {
+    const svg = generateSimpleSVG({
+      documentCount: 10, clusterCount: 2, edgeCount: 5,
+      clusters: [
+        { label: 'A', nodeCount: 5, color: '#ff0000' },
+        { label: 'B', nodeCount: 5, color: '#00ff00' },
+      ],
+      tags: [],
+    });
+    expect(svg).toContain('#ff0000');
+    expect(svg).toContain('#00ff00');
+  });
+
+  it('태그 이스케이프', () => {
+    const svg = generateSimpleSVG({
+      documentCount: 1, clusterCount: 1, edgeCount: 0,
+      clusters: [], tags: [{ tag: '<script>', count: 1 }],
+    });
+    expect(svg).not.toContain('<script>');
+    expect(svg).toContain('&lt;script');
+  });
+
+  it('빈 데이터도 에러 없이 생성', () => {
+    const svg = generateSimpleSVG({
+      documentCount: 0, clusterCount: 0, edgeCount: 0,
+      clusters: [], tags: [],
+    });
+    expect(svg).toContain('<svg');
+  });
+});

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

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { rrfFusion } from '../src/search/rrf.js';
+
+describe('rrfFusion', () => {
+  it('양쪽 리스트에 있는 항목이 상위', () => {
+    const listA = [{ chunkId: 'a', score: 0.9 }, { chunkId: 'b', score: 0.8 }];
+    const listB = [{ chunkId: 'b', score: 0.95 }, { chunkId: 'c', score: 0.7 }];
+    const result = rrfFusion(listA, listB, 60, 10);
+    expect(result[0].chunkId).toBe('b'); // 양쪽 모두 등장
+  });
+
+  it('limit 적용', () => {
+    const listA = [{ chunkId: 'a', score: 1 }, { chunkId: 'b', score: 0.9 }, { chunkId: 'c', score: 0.8 }];
+    const result = rrfFusion(listA, [], 60, 2);
+    expect(result.length).toBe(2);
+  });
+
+  it('빈 리스트 처리', () => {
+    const result = rrfFusion([], [], 60, 10);
+    expect(result).toEqual([]);
+  });
+
+  it('k 값에 따라 점수 변동', () => {
+    const list = [{ chunkId: 'a', score: 1 }];
+    const r1 = rrfFusion(list, [], 10, 10);  // 1/(10+1) = 0.0909
+    const r2 = rrfFusion(list, [], 60, 10);  // 1/(60+1) = 0.0164
+    expect(r1[0].score).toBeGreaterThan(r2[0].score);
+  });
+});

package/packages/core/tests/search-integration.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createSqliteVecStore } from '../src/store/sqlite-vec.js';
+import { createSearchEngine } from '../src/search/index.js';
+import type { VectorStore } from '../src/store/types.js';
+import type { Embedder } from '../src/indexer/embedder.js';
+
+const DIMS = 4;
+
+// 고정 벡터를 반환하는 테스트용 embedder
+function createMockEmbedder(): Embedder {
+  return {
+    modelName: 'test-mock',
+    dimensions: DIMS,
+    embed: async (text: string) => {
+      // 간단한 결정적 벡터 생성: 텍스트 길이 기반
+      const len = text.length;
+      return [len % 3 / 3, len % 5 / 5, len % 7 / 7, len % 11 / 11];
+    },
+    embedBatch: async (texts: string[]) => {
+      return Promise.all(texts.map(t => {
+        const len = t.length;
+        return [len % 3 / 3, len % 5 / 5, len % 7 / 7, len % 11 / 11];
+      }));
+    },
+  };
+}
+
+let store: VectorStore;
+let embedder: Embedder;
+
+beforeEach(async () => {
+  store = createSqliteVecStore(':memory:', DIMS);
+  await store.initialize();
+  embedder = createMockEmbedder();
+
+  // 테스트 문서 3개 삽입
+  await store.upsertDocument({
+    id: 'doc-react', filePath: 'react-patterns.md', title: 'React 상태관리 패턴',
+    content: 'React 상태관리 패턴에 대한 종합 가이드', frontmatter: {},
+    tags: ['react', 'frontend'], lastModified: '2026-01-01', contentHash: 'r1',
+  });
+  await store.upsertChunks([{
+    id: 'doc-react#0', documentId: 'doc-react',
+    content: 'React useState useReducer 패턴 비교 분석',
+    heading: 'React 상태관리', startLine: 1, endLine: 5, tokenCount: 10,
+    embedding: [0.9, 0.1, 0.2, 0.1],
+  }]);
+
+  await store.upsertDocument({
+    id: 'doc-auth', filePath: 'auth-design.md', title: 'OAuth 인증 설계',
+    content: 'OAuth 2.0 인증 흐름 설계 문서', frontmatter: {},
+    tags: ['auth', 'security'], lastModified: '2026-01-02', contentHash: 'a1',
+  });
+  await store.upsertChunks([{
+    id: 'doc-auth#0', documentId: 'doc-auth',
+    content: 'OAuth 2.0 Authorization Code Flow with PKCE',
+    heading: 'OAuth 인증', startLine: 1, endLine: 5, tokenCount: 8,
+    embedding: [0.1, 0.9, 0.1, 0.2],
+  }]);
+
+  await store.upsertDocument({
+    id: 'doc-deploy', filePath: 'deploy-lessons.md', title: '배포 실패 교훈',
+    content: '프로덕션 배포 중 발생한 장애 회고', frontmatter: {},
+    tags: ['devops', 'lessons'], lastModified: '2026-01-03', contentHash: 'd1',
+  });
+  await store.upsertChunks([{
+    id: 'doc-deploy#0', documentId: 'doc-deploy',
+    content: '배포 실패 롤백 전략과 카나리 배포 교훈',
+    heading: '배포 교훈', startLine: 1, endLine: 5, tokenCount: 12,
+    embedding: [0.2, 0.1, 0.9, 0.1],
+  }]);
+});
+
+afterEach(async () => {
+  await store.close();
+});
+
+describe('Search Integration (BM25 + Semantic + RRF)', () => {
+  it('자연어 쿼리로 결과 반환', async () => {
+    const engine = createSearchEngine({ store, embedder });
+    const results = await engine.search({ query: 'React 상태관리', limit: 5 });
+
+    expect(results.length).toBeGreaterThan(0);
+    // 각 결과에 필수 필드 존재
+    for (const r of results) {
+      expect(r.chunk).toBeDefined();
+      expect(r.document).toBeDefined();
+      expect(r.score).toBeGreaterThan(0);
+      expect(r.highlights).toBeDefined();
+    }
+  });
+
+  it('태그 필터링 동작', async () => {
+    const engine = createSearchEngine({ store, embedder });
+    const results = await engine.search({
+      query: 'React 상태관리 OAuth 배포',
+      limit: 10,
+      tags: ['auth'],
+    });
+
+    // auth 태그가 있는 문서만 반환
+    for (const r of results) {
+      expect(r.document.tags).toContain('auth');
+    }
+  });
+
+  it('limit 제한 동작', async () => {
+    const engine = createSearchEngine({ store, embedder });
+    const results = await engine.search({ query: 'React OAuth 배포', limit: 1 });
+    expect(results.length).toBeLessThanOrEqual(1);
+  });
+
+  it('빈 쿼리도 에러 없이 처리', async () => {
+    const engine = createSearchEngine({ store, embedder });
+    const results = await engine.search({ query: '', limit: 5 });
+    expect(Array.isArray(results)).toBe(true);
+  });
+
+  it('결과에 highlights 포함', async () => {
+    const engine = createSearchEngine({ store, embedder });
+    const results = await engine.search({ query: 'React', limit: 5 });
+
+    const withHighlights = results.filter(r => r.highlights.length > 0);
+    // BM25가 매칭하면 highlights가 있어야 함
+    if (results.length > 0) {
+      expect(withHighlights.length).toBeGreaterThanOrEqual(0);
+    }
+  });
+
+  it('존재하지 않는 태그 필터 시 빈 결과', async () => {
+    const engine = createSearchEngine({ store, embedder });
+    const results = await engine.search({
+      query: 'React',
+      limit: 10,
+      tags: ['nonexistent-tag'],
+    });
+    expect(results).toEqual([]);
+  });
+});

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

@@ -0,0 +1,80 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { createSqliteVecStore } from '../src/store/sqlite-vec.js';
+import type { VectorStore } from '../src/store/types.js';
+
+let store: VectorStore;
+
+beforeEach(async () => {
+  store = createSqliteVecStore(':memory:', 4); // 4차원 (테스트용)
+  await store.initialize();
+});
+
+afterEach(async () => {
+  await store.close();
+});
+
+describe('VectorStore', () => {
+  it('초기 상태 비어있음', async () => {
+    const stats = await store.getStats();
+    expect(stats.documentCount).toBe(0);
+    expect(stats.chunkCount).toBe(0);
+  });
+
+  it('document + chunk upsert 및 조회', async () => {
+    await store.upsertDocument({
+      id: 'doc1', filePath: 'test.md', title: 'Test', content: 'Hello',
+      frontmatter: {}, tags: ['test'], lastModified: '2026-01-01', contentHash: 'abc',
+    });
+    await store.upsertChunks([{
+      id: 'doc1#0', documentId: 'doc1', content: 'Hello world',
+      heading: 'Test', startLine: 1, endLine: 2, tokenCount: 3,
+      embedding: [0.1, 0.2, 0.3, 0.4],
+    }]);
+
+    const doc = await store.getDocument('doc1');
+    expect(doc).not.toBeNull();
+    expect(doc!.title).toBe('Test');
+
+    const chunk = await store.getChunk('doc1#0');
+    expect(chunk).not.toBeNull();
+    expect(chunk!.content).toBe('Hello world');
+
+    const stats = await store.getStats();
+    expect(stats.documentCount).toBe(1);
+    expect(stats.chunkCount).toBe(1);
+  });
+
+  it('semantic search', async () => {
+    await store.upsertDocument({
+      id: 'doc1', filePath: 'a.md', title: 'A', content: 'A',
+      frontmatter: {}, tags: [], lastModified: '2026-01-01', contentHash: 'a',
+    });
+    await store.upsertChunks([{
+      id: 'doc1#0', documentId: 'doc1', content: 'Content A',
+      heading: 'A', startLine: 1, endLine: 1, tokenCount: 2,
+      embedding: [1.0, 0.0, 0.0, 0.0],
+    }]);
+
+    const results = await store.searchSemantic([1.0, 0.0, 0.0, 0.0], 5);
+    expect(results.length).toBe(1);
+    expect(results[0].chunkId).toBe('doc1#0');
+    expect(results[0].score).toBeGreaterThan(0);
+  });
+
+  it('deleteByDocumentId', async () => {
+    await store.upsertDocument({
+      id: 'doc1', filePath: 'a.md', title: 'A', content: 'A',
+      frontmatter: {}, tags: [], lastModified: '2026-01-01', contentHash: 'a',
+    });
+    await store.upsertChunks([{
+      id: 'doc1#0', documentId: 'doc1', content: 'Content',
+      heading: 'A', startLine: 1, endLine: 1, tokenCount: 1,
+      embedding: [0.1, 0.2, 0.3, 0.4],
+    }]);
+
+    await store.deleteByDocumentId('doc1');
+    expect(await store.getDocument('doc1')).toBeNull();
+    const stats = await store.getStats();
+    expect(stats.chunkCount).toBe(0);
+  });
+});

package/packages/graph/index.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="ko">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Evan Knowledge Hub — 3D Knowledge Graph</title>
+    <style>
+      * { margin: 0; padding: 0; box-sizing: border-box; }
+      html, body, #root { width: 100%; height: 100%; overflow: hidden; }
+      body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #0a0a0f; color: #e0e0e0; }
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/packages/graph/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@stellavault/graph",
+  "version": "0.1.0",
+  "description": "Stellavault — 3D Neural Knowledge Graph Visualization",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@mediapipe/camera_utils": "^0.3.1675466862",
+    "@mediapipe/drawing_utils": "^0.3.1675466124",
+    "@mediapipe/hands": "^0.4.1675469240",
+    "@react-three/drei": "^10.0.0",
+    "@react-three/fiber": "^9.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-markdown": "^10.0.0",
+    "three": "^0.170.0",
+    "zustand": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@types/three": "^0.170.0",
+    "@vitejs/plugin-react": "^4.0.0",
+    "typescript": "^5.7.0",
+    "vite": "^6.0.0"
+  }
+}