memento-mcp-server 1.6.0 → 1.7.1

package/src/npm-client/types.ts

@@ -1,296 +0,0 @@
-/**
- * @memento/client 타입 정의
- * Memento MCP Server와 통신하기 위한 클라이언트 라이브러리 타입들
- */
-
-// ============================================================================
-// 기본 타입들
-// ============================================================================
-
-export type MemoryType = 'working' | 'episodic' | 'semantic' | 'procedural';
-export type PrivacyScope = 'private' | 'team' | 'public';
-
-// ============================================================================
-// 클라이언트 설정
-// ============================================================================
-
-export interface MementoClientOptions {
-  /** MCP 서버 URL (기본값: http://localhost:8080) */
-  serverUrl?: string;
-  /** API 키 (M2+에서 사용) */
-  apiKey?: string;
-  /** 연결 타임아웃 (밀리초, 기본값: 10000) */
-  timeout?: number;
-  /** 재시도 횟수 (기본값: 3) */
-  retryCount?: number;
-  /** 로그 레벨 */
-  logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent';
-}
-
-// ============================================================================
-// 기억 관련 타입들
-// ============================================================================
-
-export interface MemoryItem {
-  id: string;
-  content: string;
-  type: MemoryType;
-  importance: number;
-  created_at: string;
-  last_accessed?: string;
-  pinned: boolean;
-  source?: string;
-  tags?: string[];
-  privacy_scope: PrivacyScope;
-  project_id?: string;
-  user_id?: string;
-  metadata?: Record<string, any>;
-}
-
-export interface CreateMemoryParams {
-  content: string;
-  type?: MemoryType;
-  tags?: string[];
-  importance?: number;
-  source?: string;
-  privacy_scope?: PrivacyScope;
-  project_id?: string;
-  metadata?: Record<string, any>;
-}
-
-export interface UpdateMemoryParams {
-  content?: string;
-  type?: MemoryType;
-  tags?: string[];
-  importance?: number;
-  source?: string;
-  privacy_scope?: PrivacyScope;
-  project_id?: string;
-  metadata?: Record<string, any>;
-}
-
-// ============================================================================
-// 검색 관련 타입들
-// ============================================================================
-
-export interface SearchFilters {
-  id?: string[];
-  type?: MemoryType[];
-  tags?: string[];
-  project_id?: string;
-  time_from?: string;
-  time_to?: string;
-  pinned?: boolean;
-}
-
-export interface SearchResult {
-  items: MemorySearchResult[];
-  total_count: number;
-  query_time: number;
-  search_type?: string;
-  vector_search_available?: boolean;
-}
-
-export interface MemorySearchResult {
-  id: string;
-  content: string;
-  type: MemoryType;
-  importance: number;
-  created_at: string;
-  last_accessed?: string;
-  pinned: boolean;
-  tags?: string[];
-  privacy_scope: PrivacyScope;
-  score: number;
-  recall_reason: string;
-}
-
-export interface HybridSearchParams {
-  query: string;
-  filters?: SearchFilters;
-  limit?: number;
-  vectorWeight?: number;
-  textWeight?: number;
-}
-
-export interface HybridSearchResult {
-  items: HybridSearchItem[];
-  total_count: number;
-  query_time: number;
-  search_type: 'hybrid';
-}
-
-export interface HybridSearchItem {
-  id: string;
-  content: string;
-  type: MemoryType;
-  importance: number;
-  created_at: string;
-  last_accessed?: string;
-  pinned: boolean;
-  tags?: string[];
-  privacy_scope: PrivacyScope;
-  textScore: number;
-  vectorScore: number;
-  finalScore: number;
-  score: number; // MemorySearchResult와 호환성을 위해 추가
-  recall_reason: string;
-}
-
-// ============================================================================
-// MCP Tools 응답 타입들
-// ============================================================================
-
-export interface RememberResult {
-  memory_id: string;
-  created_at: string;
-  type: string;
-  importance: number;
-}
-
-export interface PinResult {
-  success: boolean;
-  memory_id: string;
-  pinned: boolean;
-}
-
-export interface ForgetResult {
-  success: boolean;
-  memory_id: string;
-  deleted_at: string;
-}
-
-export interface LinkResult {
-  success: boolean;
-  link_id: string;
-  source_id: string;
-  target_id: string;
-  relation_type: string;
-  created_at: string;
-}
-
-export interface ExportResult {
-  success: boolean;
-  format: string;
-  data: string;
-  count: number;
-  exported_at: string;
-}
-
-export interface FeedbackResult {
-  success: boolean;
-  memory_id: string;
-  feedback_id: string;
-  helpful: boolean;
-  created_at: string;
-}
-
-// ============================================================================
-// 컨텍스트 주입 관련 타입들
-// ============================================================================
-
-export interface ContextInjectionParams {
-  query: string;
-  token_budget?: number;
-  context_type?: 'conversation' | 'task' | 'general';
-}
-
-export interface ContextInjectionResult {
-  role: 'system';
-  content: string;
-  metadata: {
-    memories_used: number;
-    token_count: number;
-    search_time: number;
-  };
-}
-
-// ============================================================================
-// 에러 타입들
-// ============================================================================
-
-export class MementoError extends Error {
-  constructor(
-    message: string,
-    public code: string,
-    public statusCode?: number,
-    public details?: any
-  ) {
-    super(message);
-    this.name = 'MementoError';
-  }
-}
-
-export class ConnectionError extends MementoError {
-  constructor(message: string, details?: any) {
-    super(message, 'CONNECTION_ERROR', undefined, details);
-    this.name = 'ConnectionError';
-  }
-}
-
-export class AuthenticationError extends MementoError {
-  constructor(message: string, details?: any) {
-    super(message, 'AUTHENTICATION_ERROR', 401, details);
-    this.name = 'AuthenticationError';
-  }
-}
-
-export class ValidationError extends MementoError {
-  constructor(message: string, details?: any) {
-    super(message, 'VALIDATION_ERROR', 400, details);
-    this.name = 'ValidationError';
-  }
-}
-
-export class NotFoundError extends MementoError {
-  constructor(message: string, details?: any) {
-    super(message, 'NOT_FOUND', 404, details);
-    this.name = 'NotFoundError';
-  }
-}
-
-// ============================================================================
-// 이벤트 타입들
-// ============================================================================
-
-export interface MementoClientEvents {
-  'connected': () => void;
-  'disconnected': () => void;
-  'error': (error: MementoError) => void;
-  'memory:created': (memory: MemoryItem) => void;
-  'memory:updated': (memory: MemoryItem) => void;
-  'memory:deleted': (memoryId: string) => void;
-  'memory:pinned': (memoryId: string) => void;
-  'memory:unpinned': (memoryId: string) => void;
-}
-
-// ============================================================================
-// 유틸리티 타입들
-// ============================================================================
-
-export interface PaginationParams {
-  limit?: number;
-  offset?: number;
-  cursor?: string;
-}
-
-export interface PaginatedResult<T> {
-  items: T[];
-  total_count: number;
-  has_more: boolean;
-  next_cursor?: string;
-}
-
-export interface HealthCheck {
-  status: 'healthy' | 'unhealthy';
-  version: string;
-  uptime: number;
-  database: {
-    status: 'connected' | 'disconnected';
-    latency?: number;
-  };
-  search: {
-    status: 'available' | 'unavailable';
-    embedding_available: boolean;
-  };
-}

package/src/npm-client/utils.spec.ts

@@ -1,355 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  isValidMemoryType,
-  isValidPrivacyScope,
-  isValidImportance,
-  extractTagsFromContent,
-  summarizeContent,
-  calculateImportance,
-  getDefaultSettingsForType,
-  normalizeQuery,
-  normalizeScore,
-  groupSearchResults,
-  getRelativeTime,
-  createDateRangeFilter,
-  serializeMemory,
-  deserializeMemory,
-  memoriesToCSV,
-  memoriesToMarkdown,
-  validateCreateMemoryParams,
-  validateSearchParams
-} from './utils.js';
-import type { MemoryItem } from './types.js';
-
-describe('Utils', () => {
-  describe('isValidMemoryType', () => {
-    it('유효한 메모리 타입을 올바르게 검증해야 함', () => {
-      expect(isValidMemoryType('working')).toBe(true);
-      expect(isValidMemoryType('episodic')).toBe(true);
-      expect(isValidMemoryType('semantic')).toBe(true);
-      expect(isValidMemoryType('procedural')).toBe(true);
-    });
-
-    it('유효하지 않은 메모리 타입을 거부해야 함', () => {
-      expect(isValidMemoryType('invalid')).toBe(false);
-      expect(isValidMemoryType('')).toBe(false);
-      expect(isValidMemoryType(null as any)).toBe(false);
-      expect(isValidMemoryType(undefined as any)).toBe(false);
-    });
-  });
-
-  describe('isValidPrivacyScope', () => {
-    it('유효한 프라이버시 스코프를 올바르게 검증해야 함', () => {
-      expect(isValidPrivacyScope('private')).toBe(true);
-      expect(isValidPrivacyScope('team')).toBe(true);
-      expect(isValidPrivacyScope('public')).toBe(true);
-    });
-
-    it('유효하지 않은 프라이버시 스코프를 거부해야 함', () => {
-      expect(isValidPrivacyScope('invalid')).toBe(false);
-      expect(isValidPrivacyScope('')).toBe(false);
-      expect(isValidPrivacyScope(null as any)).toBe(false);
-      expect(isValidPrivacyScope(undefined as any)).toBe(false);
-    });
-  });
-
-  describe('isValidImportance', () => {
-    it('유효한 중요도 값을 검증해야 함', () => {
-      expect(isValidImportance(0.5)).toBe(true);
-      expect(isValidImportance(0)).toBe(true);
-      expect(isValidImportance(1)).toBe(true);
-    });
-
-    it('유효하지 않은 중요도 값을 거부해야 함', () => {
-      expect(isValidImportance(-0.1)).toBe(false);
-      expect(isValidImportance(1.1)).toBe(false);
-      expect(isValidImportance(NaN)).toBe(false);
-    });
-  });
-
-  describe('extractTagsFromContent', () => {
-    it('해시태그를 추출해야 함', () => {
-      const content = 'React #hooks #javascript 학습';
-      const tags = extractTagsFromContent(content);
-      
-      expect(tags).toContain('hooks');
-      expect(tags).toContain('javascript');
-    });
-
-    it('멘션을 추출해야 함', () => {
-      const content = '@user React 학습';
-      const tags = extractTagsFromContent(content);
-      
-      expect(tags).toContain('user');
-    });
-
-    it('태그 패턴을 추출해야 함', () => {
-      const content = 'type:episodic 중요도:높음';
-      const tags = extractTagsFromContent(content);
-      
-      expect(tags).toContain('type');
-      expect(tags).toContain('중요도');
-    });
-  });
-
-  describe('summarizeContent', () => {
-    it('긴 내용을 요약해야 함', () => {
-      const longContent = 'a'.repeat(500);
-      const summary = summarizeContent(longContent, 100);
-      
-      expect(summary.length).toBeLessThanOrEqual(103); // 실제 구현에서는 103자까지 허용
-      expect(summary).toContain('...');
-    });
-
-    it('짧은 내용은 그대로 반환해야 함', () => {
-      const shortContent = '짧은 내용';
-      const summary = summarizeContent(shortContent, 100);
-      
-      expect(summary).toBe(shortContent);
-    });
-  });
-
-  describe('calculateImportance', () => {
-    it('기본 중요도를 계산해야 함', () => {
-      const importance = calculateImportance({
-        content: '중요한 내용',
-        tags: ['important'],
-        pinned: false,
-        type: 'semantic'
-      });
-      
-      expect(importance).toBeGreaterThan(0);
-      expect(importance).toBeLessThanOrEqual(1);
-    });
-
-    it('고정된 기억의 중요도를 높게 계산해야 함', () => {
-      const importance = calculateImportance({
-        content: '고정된 기억',
-        tags: [],
-        pinned: true,
-        type: 'episodic'
-      });
-      
-      expect(importance).toBeGreaterThan(0.3); // 실제 구현에서는 0.4 정도 반환
-    });
-  });
-
-  describe('getDefaultSettingsForType', () => {
-    it('각 타입별 기본 설정을 반환해야 함', () => {
-      const workingSettings = getDefaultSettingsForType('working');
-      const episodicSettings = getDefaultSettingsForType('episodic');
-      
-      expect(workingSettings.importance).toBeDefined();
-      expect(episodicSettings.importance).toBeDefined();
-    });
-  });
-
-  describe('normalizeQuery', () => {
-    it('쿼리를 정규화해야 함', () => {
-      const query = '  React   Hook  ';
-      const normalized = normalizeQuery(query);
-      
-      expect(normalized).toBe('react hook'); // 실제 구현에서는 소문자로 변환
-    });
-
-    it('빈 쿼리를 처리해야 함', () => {
-      const query = '   ';
-      const normalized = normalizeQuery(query);
-      
-      expect(normalized).toBe('');
-    });
-  });
-
-  describe('normalizeScore', () => {
-    it('점수를 정규화해야 함', () => {
-      const score = normalizeScore(0.8, 0, 1);
-      expect(score).toBe(0.8);
-    });
-
-    it('범위를 벗어난 점수를 정규화해야 함', () => {
-      const score = normalizeScore(1.5, 0, 1);
-      expect(score).toBeLessThanOrEqual(1);
-    });
-  });
-
-  describe('groupSearchResults', () => {
-    it('검색 결과를 그룹화해야 함', () => {
-      const results = [
-        { id: '1', type: 'episodic', score: 0.8 },
-        { id: '2', type: 'semantic', score: 0.9 },
-        { id: '3', type: 'episodic', score: 0.7 }
-      ];
-      
-      const grouped = groupSearchResults(results, 'type');
-      
-      expect(grouped.episodic).toHaveLength(2);
-      expect(grouped.semantic).toHaveLength(1);
-    });
-  });
-
-  describe('getRelativeTime', () => {
-    it('상대 시간을 반환해야 함', () => {
-      const now = new Date();
-      const oneHourAgo = new Date(now.getTime() - 60 * 60 * 1000);
-      
-      const relativeTime = getRelativeTime(oneHourAgo);
-      
-      expect(relativeTime).toContain('시간');
-    });
-  });
-
-  describe('createDateRangeFilter', () => {
-    it('날짜 범위 필터를 생성해야 함', () => {
-      const filter = createDateRangeFilter(7);
-      
-      expect(filter.time_from).toBeDefined();
-      expect(filter.time_to).toBeDefined();
-    });
-  });
-
-  describe('serializeMemory', () => {
-    it('메모리를 직렬화해야 함', () => {
-      const memory: MemoryItem = {
-        id: 'memory-1',
-        content: 'Test memory',
-        type: 'episodic',
-        importance: 0.5,
-        created_at: '2024-01-01T00:00:00.000Z',
-        last_accessed: '2024-01-01T00:00:00.000Z',
-        pinned: false,
-        tags: ['test'],
-        source: 'user',
-        privacy_scope: 'private'
-      };
-      
-      const serialized = serializeMemory(memory);
-      
-      expect(typeof serialized).toBe('string');
-      expect(serialized).toContain('memory-1');
-    });
-  });
-
-  describe('deserializeMemory', () => {
-    it('직렬화된 메모리를 역직렬화해야 함', () => {
-      const memory: MemoryItem = {
-        id: 'memory-1',
-        content: 'Test memory',
-        type: 'episodic',
-        importance: 0.5,
-        created_at: '2024-01-01T00:00:00.000Z',
-        last_accessed: '2024-01-01T00:00:00.000Z',
-        pinned: false,
-        tags: ['test'],
-        source: 'user',
-        privacy_scope: 'private'
-      };
-      
-      const serialized = serializeMemory(memory);
-      const deserialized = deserializeMemory(serialized);
-      
-      expect(deserialized.id).toBe(memory.id);
-      expect(deserialized.content).toBe(memory.content);
-    });
-  });
-
-  describe('memoriesToCSV', () => {
-    it('메모리들을 CSV로 변환해야 함', () => {
-      const memories: MemoryItem[] = [
-        {
-          id: 'memory-1',
-          content: 'Test memory 1',
-          type: 'episodic',
-          importance: 0.5,
-          created_at: '2024-01-01T00:00:00.000Z',
-          last_accessed: '2024-01-01T00:00:00.000Z',
-          pinned: false,
-          tags: ['test'],
-          source: 'user',
-          privacy_scope: 'private'
-        }
-      ];
-      
-      const csv = memoriesToCSV(memories);
-      
-      expect(csv).toContain('id,content,type');
-      expect(csv).toContain('memory-1');
-    });
-  });
-
-  describe('memoriesToMarkdown', () => {
-    it('메모리들을 Markdown으로 변환해야 함', () => {
-      const memories: MemoryItem[] = [
-        {
-          id: 'memory-1',
-          content: 'Test memory 1',
-          type: 'episodic',
-          importance: 0.5,
-          created_at: '2024-01-01T00:00:00.000Z',
-          last_accessed: '2024-01-01T00:00:00.000Z',
-          pinned: false,
-          tags: ['test'],
-          source: 'user',
-          privacy_scope: 'private'
-        }
-      ];
-      
-      const markdown = memoriesToMarkdown(memories);
-      
-      expect(markdown).toContain('# 기억 목록'); // 실제 구현에서는 한국어 제목 사용
-      expect(markdown).toContain('Test memory 1');
-    });
-  });
-
-  describe('validateCreateMemoryParams', () => {
-    it('유효한 생성 파라미터를 검증해야 함', () => {
-      const validParams = {
-        content: 'Test memory',
-        type: 'episodic',
-        importance: 0.5,
-        tags: ['test']
-      };
-      
-      const result = validateCreateMemoryParams(validParams);
-      
-      expect(result.isValid).toBe(true);
-    });
-
-    it('유효하지 않은 생성 파라미터를 거부해야 함', () => {
-      const invalidParams = {
-        content: '',
-        type: 'invalid'
-      };
-      
-      const result = validateCreateMemoryParams(invalidParams);
-      
-      expect(result.isValid).toBe(false);
-    });
-  });
-
-  describe('validateSearchParams', () => {
-    it('유효한 검색 파라미터를 검증해야 함', () => {
-      const validParams = {
-        query: 'test',
-        limit: 10,
-        filters: {
-          type: ['episodic']
-        }
-      };
-      
-      const result = validateSearchParams(validParams);
-      
-      expect(result.isValid).toBe(true);
-    });
-
-    it('유효하지 않은 검색 파라미터를 거부해야 함', () => {
-      const invalidParams = {
-        query: '',
-        limit: -1
-      };
-      
-      const result = validateSearchParams(invalidParams);
-      
-      expect(result.isValid).toBe(false);
-    });
-  });
-});