stellavault 0.1.0 → 0.2.1

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 {}
-  });
-});

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

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

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

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