stellavault 0.1.0 → 0.2.1

package/packages/core/src/mcp/tools/get-document.ts

@@ -1,26 +0,0 @@
-import type { VectorStore } from '../../store/types.js';
-
-export const getDocumentToolDef = {
-  name: 'get-document',
-  description: '문서 ID 또는 파일 경로로 전체 문서 내용을 가져옵니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      id: { type: 'string', description: '문서 ID 또는 파일 경로' },
-    },
-    required: ['id'],
-  },
-};
-
-export async function handleGetDocument(store: VectorStore, args: { id: string }) {
-  const doc = await store.getDocument(args.id);
-  if (!doc) return { error: `Document not found: ${args.id}` };
-  return {
-    title: doc.title,
-    filePath: doc.filePath,
-    content: doc.content,
-    tags: doc.tags,
-    frontmatter: doc.frontmatter,
-    lastModified: doc.lastModified,
-  };
-}

package/packages/core/src/mcp/tools/get-related.ts

@@ -1,41 +0,0 @@
-import type { SearchEngine } from '../../search/index.js';
-import type { VectorStore } from '../../store/types.js';
-
-export const getRelatedToolDef = {
-  name: 'get-related',
-  description: '특정 문서와 의미적으로 관련된 문서들을 반환합니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      id: { type: 'string', description: '기준 문서 ID 또는 파일 경로' },
-      limit: { type: 'number', description: '반환할 관련 문서 수 (기본: 5)' },
-    },
-    required: ['id'],
-  },
-};
-
-export async function handleGetRelated(
-  store: VectorStore,
-  searchEngine: SearchEngine,
-  args: { id: string; limit?: number },
-) {
-  const doc = await store.getDocument(args.id);
-  if (!doc) return { error: `Document not found: ${args.id}` };
-
-  // 문서 제목+내용 일부를 쿼리로 사용하여 관련 문서 검색
-  const query = `${doc.title} ${doc.content.slice(0, 200)}`;
-  const results = await searchEngine.search({
-    query,
-    limit: (args.limit ?? 5) + 1, // 자기 자신 제외용 +1
-  });
-
-  return results
-    .filter(r => r.document.id !== args.id)
-    .slice(0, args.limit ?? 5)
-    .map(r => ({
-      title: r.document.title,
-      filePath: r.document.filePath,
-      score: Math.round(r.score * 1000) / 1000,
-      tags: r.document.tags,
-    }));
-}

package/packages/core/src/mcp/tools/learning-path.ts

@@ -1,52 +0,0 @@
-// MCP Tool: get-learning-path (F-A11)
-
-import type { VectorStore } from '../../store/types.js';
-import { DecayEngine } from '../../intelligence/decay-engine.js';
-import { detectKnowledgeGaps } from '../../intelligence/gap-detector.js';
-import { generateLearningPath } from '../../intelligence/learning-path.js';
-
-export function createLearningPathTool(store: VectorStore) {
-  return {
-    name: 'get-learning-path',
-    description: 'Generate a personalized learning path based on knowledge decay and gaps. Returns prioritized list of what to review, explore, or bridge.',
-    inputSchema: {
-      type: 'object' as const,
-      properties: {
-        limit: { type: 'number', description: 'Max items to return (default: 10)' },
-      },
-    },
-    async handler(args: { limit?: number }) {
-      const limit = args.limit ?? 10;
-      const db = store.getDb() as any;
-      if (!db) return { content: [{ type: 'text' as const, text: 'Database not available' }] };
-
-      const decayEngine = new DecayEngine(db);
-      const decayReport = await decayEngine.computeAll();
-
-      let gaps: any[] = [];
-      try {
-        const gapReport = await detectKnowledgeGaps(store);
-        gaps = gapReport.gaps ?? [];
-      } catch { /* ignore */ }
-
-      const path = generateLearningPath({ decayReport, gaps }, limit);
-
-      const lines = [
-        `🎯 Learning Path (${path.items.length} items, ~${path.summary.estimatedMinutes}min)`,
-        '',
-      ];
-
-      for (const item of path.items) {
-        const icon = item.category === 'review' ? '📖' : item.category === 'bridge' ? '🌉' : '🔭';
-        lines.push(`${icon} [${item.priority}] ${item.title} (${item.score}pt)`);
-        lines.push(`   ${item.reason}`);
-      }
-
-      if (path.items.length === 0) {
-        lines.push('All clear! Knowledge is in great shape.');
-      }
-
-      return { content: [{ type: 'text' as const, text: lines.join('\n') }] };
-    },
-  };
-}

package/packages/core/src/mcp/tools/list-topics.ts

@@ -1,20 +0,0 @@
-import type { VectorStore } from '../../store/types.js';
-
-export const listTopicsToolDef = {
-  name: 'list-topics',
-  description: '지식 베이스의 전체 토픽/태그 목록과 문서 수를 반환합니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {},
-  },
-};
-
-export async function handleListTopics(store: VectorStore) {
-  const topics = await store.getTopics();
-  const stats = await store.getStats();
-  return {
-    topics,
-    totalDocuments: stats.documentCount,
-    totalChunks: stats.chunkCount,
-  };
-}

package/packages/core/src/mcp/tools/search.ts

@@ -1,35 +0,0 @@
-import type { SearchEngine } from '../../search/index.js';
-
-export const searchToolDef = {
-  name: 'search',
-  description: '개인 지식 베이스에서 관련 문서/청크를 검색합니다. 자연어 쿼리와 키워드 모두 지원합니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      query: { type: 'string', description: '검색 쿼리 (자연어 또는 키워드)' },
-      limit: { type: 'number', description: '반환할 결과 수 (기본: 5)' },
-      tags: { type: 'array', items: { type: 'string' }, description: '태그 필터' },
-    },
-    required: ['query'],
-  },
-};
-
-export async function handleSearch(
-  searchEngine: SearchEngine,
-  args: { query: string; limit?: number; tags?: string[] },
-) {
-  const results = await searchEngine.search({
-    query: args.query,
-    limit: args.limit ?? 5,
-    tags: args.tags,
-  });
-
-  return results.map(r => ({
-    title: r.document.title,
-    filePath: r.document.filePath,
-    heading: r.chunk.heading,
-    content: r.chunk.content,
-    score: Math.round(r.score * 1000) / 1000,
-    tags: r.document.tags,
-  }));
-}

package/packages/core/src/mcp/tools/snapshot.ts

@@ -1,98 +0,0 @@
-// Design Ref: §12.1 F10 — 컨텍스트 스냅샷 (프로젝트별 지식 묶음)
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
-import { join, resolve, relative } from 'node:path';
-import { homedir } from 'node:os';
-import type { SearchEngine } from '../../search/index.js';
-
-const SNAPSHOT_DIR = join(homedir(), '.stellavault', 'snapshots');
-
-function sanitizeName(name: string): string {
-  const sanitized = name.replace(/[^a-zA-Z0-9가-힣_-]/g, '');
-  if (!sanitized) throw new Error('Invalid snapshot name');
-  return sanitized;
-}
-
-function ensureWithinDir(dir: string, filePath: string): string {
-  const resolved = resolve(dir, filePath);
-  if (!resolved.startsWith(resolve(dir))) {
-    throw new Error('Path traversal detected');
-  }
-  return resolved;
-}
-
-export const createSnapshotToolDef = {
-  name: 'create-snapshot',
-  description: '현재 프로젝트 관련 지식을 스냅샷으로 저장합니다. 나중에 load-snapshot으로 즉시 컨텍스트 복원.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      name: { type: 'string', description: '스냅샷 이름 (예: my-project-v1)' },
-      queries: { type: 'array', items: { type: 'string' }, description: '관련 지식 검색 쿼리들' },
-    },
-    required: ['name', 'queries'],
-  },
-};
-
-export const loadSnapshotToolDef = {
-  name: 'load-snapshot',
-  description: '저장된 스냅샷을 로드하여 프로젝트 컨텍스트를 즉시 복원합니다.',
-  inputSchema: {
-    type: 'object' as const,
-    properties: {
-      name: { type: 'string', description: '스냅샷 이름' },
-    },
-    required: ['name'],
-  },
-};
-
-export async function handleCreateSnapshot(
-  searchEngine: SearchEngine,
-  args: { name: string; queries: string[] },
-) {
-  mkdirSync(SNAPSHOT_DIR, { recursive: true });
-
-  const results = [];
-  for (const query of args.queries) {
-    const hits = await searchEngine.search({ query, limit: 5 });
-    results.push(...hits.map(r => ({
-      query,
-      title: r.document.title,
-      filePath: r.document.filePath,
-      heading: r.chunk.heading,
-      content: r.chunk.content.slice(0, 500),
-      score: r.score,
-    })));
-  }
-
-  // 중복 제거
-  const seen = new Set<string>();
-  const unique = results.filter(r => {
-    const key = `${r.filePath}:${r.heading}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
-  });
-
-  const snapshot = {
-    name: args.name,
-    createdAt: new Date().toISOString(),
-    queries: args.queries,
-    results: unique,
-  };
-
-  const safeName = sanitizeName(args.name);
-  const filePath = ensureWithinDir(SNAPSHOT_DIR, `${safeName}.json`);
-  writeFileSync(filePath, JSON.stringify(snapshot, null, 2), 'utf-8');
-
-  return { saved: filePath, resultCount: unique.length };
-}
-
-export async function handleLoadSnapshot(args: { name: string }) {
-  const safeName = sanitizeName(args.name);
-  const filePath = ensureWithinDir(SNAPSHOT_DIR, `${safeName}.json`);
-  if (!existsSync(filePath)) {
-    return { error: `Snapshot not found: ${args.name}` };
-  }
-  return JSON.parse(readFileSync(filePath, 'utf-8'));
-}

package/packages/core/src/multi-vault/index.ts

@@ -1,118 +0,0 @@
-// Cross-Vault Federation (P3-F24)
-// 한 사람의 여러 vault를 통합 검색
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import type { VectorStore } from '../store/types.js';
-import type { Embedder } from '../indexer/embedder.js';
-import type { ScoredChunk } from '../types/chunk.js';
-
-export interface VaultEntry {
-  id: string;          // short alias
-  name: string;        // display name
-  path: string;        // vault path
-  dbPath: string;      // index.db path
-  shared: boolean;     // 공유 허용 여부 (Federation에서)
-  addedAt: string;
-}
-
-export interface CrossVaultSearchResult {
-  vaultId: string;
-  vaultName: string;
-  title: string;
-  score: number;
-  snippet: string;
-  filePath: string;
-}
-
-const VAULTS_FILE = join(homedir(), '.stellavault', 'vaults.json');
-
-function loadVaults(): VaultEntry[] {
-  if (!existsSync(VAULTS_FILE)) return [];
-  return JSON.parse(readFileSync(VAULTS_FILE, 'utf-8'));
-}
-
-function saveVaults(vaults: VaultEntry[]): void {
-  mkdirSync(join(homedir(), '.stellavault'), { recursive: true });
-  writeFileSync(VAULTS_FILE, JSON.stringify(vaults, null, 2), 'utf-8');
-}
-
-export function addVault(id: string, name: string, vaultPath: string, dbPath: string, shared = false): VaultEntry {
-  const vaults = loadVaults();
-  if (vaults.some(v => v.id === id)) {
-    throw new Error(`Vault "${id}" already exists`);
-  }
-  const entry: VaultEntry = { id, name, path: vaultPath, dbPath, shared, addedAt: new Date().toISOString() };
-  vaults.push(entry);
-  saveVaults(vaults);
-  return entry;
-}
-
-export function removeVault(id: string): boolean {
-  const vaults = loadVaults();
-  const filtered = vaults.filter(v => v.id !== id);
-  if (filtered.length === vaults.length) return false;
-  saveVaults(filtered);
-  return true;
-}
-
-export function listVaults(): VaultEntry[] {
-  return loadVaults();
-}
-
-export function getVault(id: string): VaultEntry | undefined {
-  return loadVaults().find(v => v.id === id);
-}
-
-// 모든 vault를 통합 검색
-export async function searchAllVaults(
-  query: string,
-  embedder: Embedder,
-  createStore: (dbPath: string) => VectorStore,
-  options: { limit?: number } = {},
-): Promise<CrossVaultSearchResult[]> {
-  const { limit = 10 } = options;
-  const vaults = loadVaults();
-  const results: CrossVaultSearchResult[] = [];
-
-  // 쿼리 임베딩 (한 번만)
-  const embedding = await embedder.embed(query);
-
-  // 각 vault에서 병렬 검색
-  const searches = vaults.map(async (vault) => {
-    try {
-      if (!existsSync(vault.dbPath)) return;
-
-      const store = createStore(vault.dbPath);
-      await store.initialize();
-
-      const scored = await store.searchSemantic(embedding, limit);
-
-      for (const s of scored) {
-        const chunk = await store.getChunk(s.chunkId);
-        if (!chunk) continue;
-        const doc = await store.getDocument(chunk.documentId);
-
-        results.push({
-          vaultId: vault.id,
-          vaultName: vault.name,
-          title: doc?.title ?? 'Untitled',
-          score: s.score,
-          snippet: chunk.content.slice(0, 80),
-          filePath: doc?.filePath ?? '',
-        });
-      }
-
-      await store.close();
-    } catch {
-      // vault 접근 실패 시 건너뜀
-    }
-  });
-
-  await Promise.allSettled(searches);
-
-  return results
-    .sort((a, b) => b.score - a.score)
-    .slice(0, limit);
-}

package/packages/core/src/pack/creator.ts

@@ -1,127 +0,0 @@
-// Design Ref: Phase 3 FR-01~03 — 검색/클러스터 기반 팩 생성
-
-import type { VectorStore } from '../store/types.js';
-import type { SearchEngine } from '../search/index.js';
-import type { Embedder } from '../indexer/embedder.js';
-import type { KnowledgePack, PackChunk } from './types.js';
-import { maskPII } from './pii-masker.js';
-
-export interface CreatePackOptions {
-  name: string;
-  author?: string;
-  license?: string;
-  description?: string;
-  fromSearch?: string;
-  fromCluster?: number;
-  limit?: number;
-}
-
-export async function createPack(
-  store: VectorStore,
-  searchEngine: SearchEngine,
-  embedder: Embedder,
-  options: CreatePackOptions,
-): Promise<{ pack: KnowledgePack; piiReport: { redactedCount: number; types: string[] } }> {
-  const { name, author = 'anonymous', license = 'CC-BY-4.0', description = '', limit = 100 } = options;
-
-  let chunkIds: string[] = [];
-
-  if (options.fromSearch) {
-    // 검색 결과에서 청크 수집
-    const results = await searchEngine.search({ query: options.fromSearch, limit });
-    chunkIds = results.map(r => r.chunk.id);
-  } else if (options.fromCluster !== undefined) {
-    // 클러스터의 문서에서 청크 수집
-    const docs = await store.getAllDocuments();
-    const embeddings = await store.getDocumentEmbeddings();
-
-    // 간단한 클러스터 매칭: graph-data의 K-means 결과를 재활용할 수 없으므로
-    // 해당 클러스터 문서의 모든 청크를 가져옴
-    // 여기서는 fromSearch를 권장하되, fromCluster는 문서 ID 기반으로 처리
-    const clusterDocs = docs.slice(0, limit);
-    for (const doc of clusterDocs) {
-      const chunk = await store.getChunk(`${doc.id}#0`);
-      if (chunk) chunkIds.push(chunk.id);
-    }
-  }
-
-  // 청크 데이터 수집 + PII 마스킹
-  const chunks: PackChunk[] = [];
-  let totalRedacted = 0;
-  const allTypes = new Set<string>();
-
-  for (const chunkId of chunkIds) {
-    const chunk = await store.getChunk(chunkId);
-    if (!chunk) continue;
-
-    const doc = await store.getDocument(chunk.documentId);
-    if (!doc) continue;
-
-    // PII 마스킹
-    const { masked, redactedCount, redactedTypes } = maskPII(chunk.content);
-    totalRedacted += redactedCount;
-    redactedTypes.forEach(t => allTypes.add(t));
-
-    // 임베딩 재생성 (마스킹된 텍스트로)
-    const embedding = await embedder.embed(masked);
-
-    chunks.push({
-      id: chunkId,
-      content: masked,
-      heading: chunk.heading,
-      embedding,
-      metadata: {
-        sourceFile: doc.filePath,
-        category: detectCategory(doc.filePath, chunk.content),
-        language: detectLanguage(chunk.content),
-      },
-    });
-  }
-
-  const pack: KnowledgePack = {
-    name,
-    version: '1.0.0',
-    author,
-    license,
-    description: description || `Knowledge pack: ${name}`,
-    tags: extractPackTags(chunks),
-    embeddingModel: embedder.modelName,
-    embeddingDimensions: embedder.dimensions,
-    schemaVersion: '1.0',
-    chunks,
-    createdAt: new Date().toISOString(),
-  };
-
-  return {
-    pack,
-    piiReport: { redactedCount: totalRedacted, types: [...allTypes] },
-  };
-}
-
-function detectCategory(filePath: string, content: string): string {
-  const lower = filePath.toLowerCase() + ' ' + content.slice(0, 200).toLowerCase();
-  if (lower.includes('lesson') || lower.includes('교훈')) return 'lesson';
-  if (lower.includes('pattern') || lower.includes('패턴')) return 'pattern';
-  if (lower.includes('decision') || lower.includes('결정')) return 'decision';
-  if (lower.includes('design') || lower.includes('설계')) return 'reference';
-  return 'reference';
-}
-
-function detectLanguage(content: string): string | undefined {
-  if (content.includes('typescript') || content.includes('.ts')) return 'typescript';
-  if (content.includes('python') || content.includes('.py')) return 'python';
-  if (content.includes('react') || content.includes('jsx')) return 'react';
-  return undefined;
-}
-
-function extractPackTags(chunks: PackChunk[]): string[] {
-  const wordCounts = new Map<string, number>();
-  for (const c of chunks) {
-    const words = c.heading.split(/\s+/).filter(w => w.length > 2);
-    for (const w of words) wordCounts.set(w, (wordCounts.get(w) ?? 0) + 1);
-  }
-  return [...wordCounts.entries()]
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, 10)
-    .map(([w]) => w);
-}

package/packages/core/src/pack/exporter.ts

@@ -1,21 +0,0 @@
-// Design Ref: Phase 3 FR-05 — .sv-pack 파일 내보내기
-
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-import type { KnowledgePack } from './types.js';
-
-export function exportPack(pack: KnowledgePack, outputPath: string): void {
-  mkdirSync(dirname(outputPath), { recursive: true });
-  writeFileSync(outputPath, JSON.stringify(pack, null, 2), 'utf-8');
-}
-
-export function packToSummary(pack: KnowledgePack): string {
-  return [
-    `Name: ${pack.name} v${pack.version}`,
-    `Author: ${pack.author} (${pack.license})`,
-    `Chunks: ${pack.chunks.length}`,
-    `Model: ${pack.embeddingModel} (${pack.embeddingDimensions}d)`,
-    `Tags: ${pack.tags.join(', ')}`,
-    `Created: ${pack.createdAt}`,
-  ].join('\n');
-}

package/packages/core/src/pack/importer.ts

@@ -1,82 +0,0 @@
-// Design Ref: Phase 3 FR-06~07 — .sv-pack 가져오기 + 벡터 DB 병합
-
-import { readFileSync } from 'node:fs';
-import type { VectorStore } from '../store/types.js';
-import type { Embedder } from '../indexer/embedder.js';
-import type { KnowledgePack } from './types.js';
-
-export interface ImportResult {
-  imported: number;
-  skipped: number;
-  reEmbedded: number;
-  modelMismatch: boolean;
-}
-
-export async function importPack(
-  store: VectorStore,
-  embedder: Embedder,
-  filePath: string,
-): Promise<ImportResult> {
-  const raw = readFileSync(filePath, 'utf-8');
-  const pack: KnowledgePack = JSON.parse(raw);
-
-  // 임베딩 모델 불일치 감지
-  const modelMismatch = pack.embeddingModel !== embedder.modelName ||
-    pack.embeddingDimensions !== embedder.dimensions;
-
-  let imported = 0;
-  let skipped = 0;
-  let reEmbedded = 0;
-
-  // 팩 문서를 pack_{name} prefix로 저장
-  const packDocId = `pack_${pack.name}`;
-
-  await store.upsertDocument({
-    id: packDocId,
-    filePath: `[pack] ${pack.name}`,
-    title: `${pack.name} (Knowledge Pack)`,
-    content: `Imported pack: ${pack.description}\nChunks: ${pack.chunks.length}\nAuthor: ${pack.author}`,
-    frontmatter: { pack: pack.name, license: pack.license },
-    tags: pack.tags,
-    lastModified: pack.createdAt,
-    contentHash: `pack_${pack.name}_${pack.version}`,
-  });
-
-  const chunks = [];
-  for (let i = 0; i < pack.chunks.length; i++) {
-    const pc = pack.chunks[i];
-
-    let embedding = pc.embedding;
-
-    // 모델 불일치 시 재임베딩
-    if (modelMismatch) {
-      embedding = await embedder.embed(pc.content);
-      reEmbedded++;
-    }
-
-    // 차원 검증
-    if (embedding.length !== embedder.dimensions) {
-      skipped++;
-      continue;
-    }
-
-    chunks.push({
-      id: `${packDocId}#${i}`,
-      documentId: packDocId,
-      content: pc.content,
-      heading: pc.heading || pack.name,
-      startLine: 0,
-      endLine: 0,
-      tokenCount: Math.ceil(pc.content.length / 4),
-      embedding,
-    });
-
-    imported++;
-  }
-
-  if (chunks.length > 0) {
-    await store.upsertChunks(chunks);
-  }
-
-  return { imported, skipped, reEmbedded, modelMismatch };
-}