claude-session-continuity-mcp 1.0.0

package/dist/utils/auto-context.d.ts

@@ -0,0 +1,58 @@
+export interface ProjectContext {
+    project: string;
+    fixed: {
+        techStack: Record<string, string>;
+        architectureDecisions: string[];
+        codePatterns: string[];
+        specialNotes: string | null;
+    };
+    active: {
+        currentState: string;
+        recentFiles: string[];
+        blockers: string | null;
+        lastVerification: string | null;
+        updatedAt: string | null;
+    };
+    pendingTasks: Array<{
+        id: number;
+        title: string;
+        status: string;
+        priority: number;
+    }>;
+}
+export interface ContextSnapshot {
+    project: string;
+    timestamp: string;
+    tokenEstimate: number;
+    context: ProjectContext;
+}
+/**
+ * 컨텍스트의 총 토큰 수 추정
+ */
+export declare function estimateContextTokens(context: ProjectContext): number;
+/**
+ * 프로젝트 컨텍스트 자동 로드 (캐시 우선)
+ * 목표: < 5ms (캐시 히트 시)
+ */
+export declare function loadContext(project: string): Promise<ProjectContext>;
+export interface SaveContextOptions {
+    currentState: string;
+    recentFiles?: string[];
+    blockers?: string | null;
+    verification?: 'passed' | 'failed' | null;
+    architectureDecision?: string;
+    codePattern?: string;
+    techStack?: Record<string, string>;
+}
+/**
+ * 프로젝트 컨텍스트 자동 저장
+ */
+export declare function saveContext(project: string, options: SaveContextOptions): Promise<void>;
+/**
+ * 현재 컨텍스트의 스냅샷 생성 (토큰 추정 포함)
+ */
+export declare function createContextSnapshot(project: string): Promise<ContextSnapshot>;
+/**
+ * 토큰 효율적 컨텍스트 요약 (650토큰 목표)
+ */
+export declare function getCompactContext(project: string): Promise<string>;

package/dist/utils/auto-context.js

@@ -0,0 +1,234 @@
+// 자동 컨텍스트 캡처 시스템
+// 세션 시작 시 자동 로드, 세션 종료 시 자동 저장
+import { db } from '../db/database.js';
+import { logger } from './logger.js';
+import { contextCache, makeContextKey, invalidateContext } from './cache.js';
+// ===== 토큰 추정 =====
+/**
+ * 문자열의 토큰 수 추정 (평균 4자 = 1토큰)
+ */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * 컨텍스트의 총 토큰 수 추정
+ */
+export function estimateContextTokens(context) {
+    const json = JSON.stringify(context);
+    return estimateTokens(json);
+}
+// ===== 자동 컨텍스트 로드 =====
+/**
+ * 프로젝트 컨텍스트 자동 로드 (캐시 우선)
+ * 목표: < 5ms (캐시 히트 시)
+ */
+export async function loadContext(project) {
+    const startTime = performance.now();
+    const cacheKey = makeContextKey(project);
+    // 캐시 확인
+    const cached = contextCache.get(cacheKey);
+    if (cached) {
+        const elapsed = performance.now() - startTime;
+        logger.debug('Context loaded from cache', { project, elapsed: `${elapsed.toFixed(2)}ms` });
+        return cached;
+    }
+    // DB에서 로드
+    const context = await loadContextFromDB(project);
+    // 캐시에 저장
+    contextCache.set(cacheKey, context);
+    const elapsed = performance.now() - startTime;
+    logger.info('Context loaded from DB', { project, elapsed: `${elapsed.toFixed(2)}ms` });
+    return context;
+}
+/**
+ * DB에서 컨텍스트 로드 (내부용)
+ */
+async function loadContextFromDB(project) {
+    // Layer 1: 고정 컨텍스트
+    const projectContextStmt = db.prepare('SELECT * FROM project_context WHERE project = ?');
+    const projectContext = projectContextStmt.get(project);
+    // Layer 2: 활성 컨텍스트
+    const activeContextStmt = db.prepare('SELECT * FROM active_context WHERE project = ?');
+    const activeContext = activeContextStmt.get(project);
+    // Layer 3: 미완료 태스크 (최대 3개, 우선순위순)
+    const tasksStmt = db.prepare(`
+    SELECT id, title, status, priority
+    FROM tasks
+    WHERE project = ? AND status IN ('pending', 'in_progress')
+    ORDER BY priority DESC, created_at DESC
+    LIMIT 3
+  `);
+    const tasks = tasksStmt.all(project);
+    return {
+        project,
+        fixed: {
+            techStack: projectContext?.tech_stack ? JSON.parse(projectContext.tech_stack) : {},
+            architectureDecisions: projectContext?.architecture_decisions ? JSON.parse(projectContext.architecture_decisions) : [],
+            codePatterns: projectContext?.code_patterns ? JSON.parse(projectContext.code_patterns) : [],
+            specialNotes: projectContext?.special_notes || null
+        },
+        active: {
+            currentState: activeContext?.current_state || 'No active context',
+            recentFiles: activeContext?.recent_files ? JSON.parse(activeContext.recent_files) : [],
+            blockers: activeContext?.blockers || null,
+            lastVerification: activeContext?.last_verification || null,
+            updatedAt: activeContext?.updated_at || null
+        },
+        pendingTasks: tasks
+    };
+}
+/**
+ * 프로젝트 컨텍스트 자동 저장
+ */
+export async function saveContext(project, options) {
+    const startTime = performance.now();
+    const transaction = db.transaction(() => {
+        // 활성 컨텍스트 업데이트
+        const activeStmt = db.prepare(`
+      INSERT OR REPLACE INTO active_context (project, current_state, recent_files, blockers, last_verification, updated_at)
+      VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+    `);
+        activeStmt.run(project, options.currentState, options.recentFiles ? JSON.stringify(options.recentFiles.slice(0, 10)) : null, options.blockers || null, options.verification || null);
+        // 아키텍처 결정 추가 (있으면)
+        if (options.architectureDecision) {
+            updateArchitectureDecision(project, options.architectureDecision);
+        }
+        // 코드 패턴 추가 (있으면)
+        if (options.codePattern) {
+            updateCodePattern(project, options.codePattern);
+        }
+        // 기술 스택 업데이트 (있으면)
+        if (options.techStack) {
+            updateTechStack(project, options.techStack);
+        }
+    });
+    transaction();
+    // 캐시 무효화
+    invalidateContext(project);
+    const elapsed = performance.now() - startTime;
+    logger.info('Context saved', { project, elapsed: `${elapsed.toFixed(2)}ms` });
+}
+// ===== 고정 컨텍스트 업데이트 헬퍼 =====
+function updateArchitectureDecision(project, decision) {
+    const getStmt = db.prepare('SELECT architecture_decisions FROM project_context WHERE project = ?');
+    const row = getStmt.get(project);
+    let decisions = [];
+    if (row?.architecture_decisions) {
+        try {
+            decisions = JSON.parse(row.architecture_decisions);
+        }
+        catch { /* ignore */ }
+    }
+    // 중복 제거 후 앞에 추가 (최대 5개)
+    decisions = decisions.filter(d => d !== decision);
+    decisions.unshift(decision);
+    decisions = decisions.slice(0, 5);
+    const upsertStmt = db.prepare(`
+    INSERT INTO project_context (project, architecture_decisions, updated_at)
+    VALUES (?, ?, CURRENT_TIMESTAMP)
+    ON CONFLICT(project) DO UPDATE SET
+      architecture_decisions = ?,
+      updated_at = CURRENT_TIMESTAMP
+  `);
+    const json = JSON.stringify(decisions);
+    upsertStmt.run(project, json, json);
+}
+function updateCodePattern(project, pattern) {
+    const getStmt = db.prepare('SELECT code_patterns FROM project_context WHERE project = ?');
+    const row = getStmt.get(project);
+    let patterns = [];
+    if (row?.code_patterns) {
+        try {
+            patterns = JSON.parse(row.code_patterns);
+        }
+        catch { /* ignore */ }
+    }
+    // 중복 제거 후 앞에 추가 (최대 5개)
+    patterns = patterns.filter(p => p !== pattern);
+    patterns.unshift(pattern);
+    patterns = patterns.slice(0, 5);
+    const upsertStmt = db.prepare(`
+    INSERT INTO project_context (project, code_patterns, updated_at)
+    VALUES (?, ?, CURRENT_TIMESTAMP)
+    ON CONFLICT(project) DO UPDATE SET
+      code_patterns = ?,
+      updated_at = CURRENT_TIMESTAMP
+  `);
+    const json = JSON.stringify(patterns);
+    upsertStmt.run(project, json, json);
+}
+function updateTechStack(project, newStack) {
+    const getStmt = db.prepare('SELECT tech_stack FROM project_context WHERE project = ?');
+    const row = getStmt.get(project);
+    let stack = {};
+    if (row?.tech_stack) {
+        try {
+            stack = JSON.parse(row.tech_stack);
+        }
+        catch { /* ignore */ }
+    }
+    // 병합 (새 값이 기존 값 덮어씀)
+    stack = { ...stack, ...newStack };
+    const upsertStmt = db.prepare(`
+    INSERT INTO project_context (project, tech_stack, updated_at)
+    VALUES (?, ?, CURRENT_TIMESTAMP)
+    ON CONFLICT(project) DO UPDATE SET
+      tech_stack = ?,
+      updated_at = CURRENT_TIMESTAMP
+  `);
+    const json = JSON.stringify(stack);
+    upsertStmt.run(project, json, json);
+}
+// ===== 컨텍스트 스냅샷 =====
+/**
+ * 현재 컨텍스트의 스냅샷 생성 (토큰 추정 포함)
+ */
+export async function createContextSnapshot(project) {
+    const context = await loadContext(project);
+    const tokenEstimate = estimateContextTokens(context);
+    return {
+        project,
+        timestamp: new Date().toISOString(),
+        tokenEstimate,
+        context
+    };
+}
+// ===== 컨텍스트 요약 =====
+/**
+ * 토큰 효율적 컨텍스트 요약 (650토큰 목표)
+ */
+export async function getCompactContext(project) {
+    const context = await loadContext(project);
+    const lines = [
+        `# ${project}`,
+        '',
+    ];
+    // 기술 스택 (간결하게)
+    if (Object.keys(context.fixed.techStack).length > 0) {
+        const stackStr = Object.entries(context.fixed.techStack)
+            .map(([k, v]) => `${k}: ${v}`)
+            .join(', ');
+        lines.push(`**Stack**: ${stackStr}`);
+    }
+    // 아키텍처 결정 (최대 3개)
+    if (context.fixed.architectureDecisions.length > 0) {
+        lines.push(`**Decisions**: ${context.fixed.architectureDecisions.slice(0, 3).join(' | ')}`);
+    }
+    // 현재 상태
+    lines.push(`**State**: ${context.active.currentState}`);
+    // 최근 파일 (최대 5개)
+    if (context.active.recentFiles.length > 0) {
+        const files = context.active.recentFiles.slice(0, 5).map(f => f.split('/').pop()).join(', ');
+        lines.push(`**Files**: ${files}`);
+    }
+    // 블로커
+    if (context.active.blockers) {
+        lines.push(`**Blocker**: ${context.active.blockers}`);
+    }
+    // 미완료 태스크
+    if (context.pendingTasks.length > 0) {
+        const tasks = context.pendingTasks.map(t => `[P${t.priority}] ${t.title}`).join(' | ');
+        lines.push(`**Tasks**: ${tasks}`);
+    }
+    return lines.join('\n');
+}

package/dist/utils/cache.d.ts

@@ -0,0 +1,60 @@
+interface CacheOptions {
+    maxSize: number;
+    ttlMs: number;
+}
+export declare class QueryCache<T = unknown> {
+    private cache;
+    private options;
+    private hits;
+    private misses;
+    constructor(options?: Partial<CacheOptions>);
+    /**
+     * 캐시에서 값 조회
+     * @returns 캐시된 값 또는 undefined
+     */
+    get(key: string): T | undefined;
+    /**
+     * 캐시에 값 저장
+     */
+    set(key: string, value: T): void;
+    /**
+     * 캐시에서 값 조회 또는 생성
+     */
+    getOrSet(key: string, factory: () => T | Promise<T>): Promise<T>;
+    /**
+     * 특정 키 무효화
+     */
+    invalidate(key: string): boolean;
+    /**
+     * 패턴과 일치하는 모든 키 무효화
+     */
+    invalidatePattern(pattern: string | RegExp): number;
+    /**
+     * 전체 캐시 초기화
+     */
+    clear(): void;
+    /**
+     * 캐시 통계
+     */
+    getStats(): {
+        size: number;
+        maxSize: number;
+        hits: number;
+        misses: number;
+        hitRate: number;
+    };
+    /**
+     * LRU 항목 제거
+     */
+    private evictLRU;
+}
+export declare const contextCache: QueryCache<unknown>;
+export declare const memoryCache: QueryCache<unknown>;
+export declare const projectCache: QueryCache<unknown>;
+export declare function makeContextKey(project: string): string;
+export declare function makeMemoryKey(query: string, project?: string, type?: string): string;
+export declare function makeProjectKey(): string;
+export declare function invalidateContext(project: string): void;
+export declare function invalidateMemory(project?: string): void;
+export declare function invalidateProjects(): void;
+export {};

package/dist/utils/cache.js

@@ -0,0 +1,161 @@
+// 쿼리 캐싱 시스템 - 5ms 읽기 목표
+// LRU 캐시 + TTL 기반 무효화
+const DEFAULT_OPTIONS = {
+    maxSize: 100,
+    ttlMs: 30000 // 30초
+};
+export class QueryCache {
+    cache;
+    options;
+    hits = 0;
+    misses = 0;
+    constructor(options = {}) {
+        this.cache = new Map();
+        this.options = { ...DEFAULT_OPTIONS, ...options };
+    }
+    /**
+     * 캐시에서 값 조회
+     * @returns 캐시된 값 또는 undefined
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.misses++;
+            return undefined;
+        }
+        // TTL 체크
+        if (Date.now() - entry.createdAt > this.options.ttlMs) {
+            this.cache.delete(key);
+            this.misses++;
+            return undefined;
+        }
+        // 접근 횟수 증가
+        entry.accessCount++;
+        this.hits++;
+        return entry.value;
+    }
+    /**
+     * 캐시에 값 저장
+     */
+    set(key, value) {
+        // 최대 크기 초과 시 LRU 제거
+        if (this.cache.size >= this.options.maxSize) {
+            this.evictLRU();
+        }
+        this.cache.set(key, {
+            value,
+            createdAt: Date.now(),
+            accessCount: 0
+        });
+    }
+    /**
+     * 캐시에서 값 조회 또는 생성
+     */
+    async getOrSet(key, factory) {
+        const cached = this.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const value = await factory();
+        this.set(key, value);
+        return value;
+    }
+    /**
+     * 특정 키 무효화
+     */
+    invalidate(key) {
+        return this.cache.delete(key);
+    }
+    /**
+     * 패턴과 일치하는 모든 키 무효화
+     */
+    invalidatePattern(pattern) {
+        const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+        let count = 0;
+        for (const key of this.cache.keys()) {
+            if (regex.test(key)) {
+                this.cache.delete(key);
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * 전체 캐시 초기화
+     */
+    clear() {
+        this.cache.clear();
+        this.hits = 0;
+        this.misses = 0;
+    }
+    /**
+     * 캐시 통계
+     */
+    getStats() {
+        const total = this.hits + this.misses;
+        return {
+            size: this.cache.size,
+            maxSize: this.options.maxSize,
+            hits: this.hits,
+            misses: this.misses,
+            hitRate: total > 0 ? this.hits / total : 0
+        };
+    }
+    /**
+     * LRU 항목 제거
+     */
+    evictLRU() {
+        let lruKey;
+        let lruCount = Infinity;
+        for (const [key, entry] of this.cache.entries()) {
+            if (entry.accessCount < lruCount) {
+                lruCount = entry.accessCount;
+                lruKey = key;
+            }
+        }
+        if (lruKey) {
+            this.cache.delete(lruKey);
+        }
+    }
+}
+// ===== 전역 캐시 인스턴스 =====
+// 컨텍스트 캐시 (자주 조회)
+export const contextCache = new QueryCache({
+    maxSize: 50,
+    ttlMs: 60000 // 1분
+});
+// 메모리 검색 캐시
+export const memoryCache = new QueryCache({
+    maxSize: 100,
+    ttlMs: 30000 // 30초
+});
+// 프로젝트 목록 캐시
+export const projectCache = new QueryCache({
+    maxSize: 20,
+    ttlMs: 120000 // 2분
+});
+// ===== 캐시 키 생성 헬퍼 =====
+export function makeContextKey(project) {
+    return `context:${project}`;
+}
+export function makeMemoryKey(query, project, type) {
+    return `memory:${project || '*'}:${type || '*'}:${query}`;
+}
+export function makeProjectKey() {
+    return 'projects:list';
+}
+// ===== 캐시 무효화 트리거 =====
+export function invalidateContext(project) {
+    contextCache.invalidate(makeContextKey(project));
+}
+export function invalidateMemory(project) {
+    if (project) {
+        memoryCache.invalidatePattern(`memory:${project}:`);
+    }
+    else {
+        memoryCache.clear();
+    }
+}
+export function invalidateProjects() {
+    projectCache.invalidate(makeProjectKey());
+}

package/dist/utils/embedding.d.ts

@@ -0,0 +1,7 @@
+export declare function initEmbedding(): Promise<void>;
+export declare function generateEmbedding(text: string): Promise<number[] | null>;
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+export declare function embeddingToBuffer(embedding: number[]): Buffer;
+export declare function bufferToEmbedding(buffer: Buffer): number[];
+export declare function isEmbeddingReady(): boolean;
+export declare function getEmbeddingPipeline(): unknown;

package/dist/utils/embedding.js

@@ -0,0 +1,67 @@
+// 임베딩 관련 유틸리티
+import * as path from 'path';
+// @ts-ignore - transformers.js
+import { pipeline, env } from '@xenova/transformers';
+// 모델 캐시 설정
+env.cacheDir = path.join(process.env.HOME || '/tmp', '.cache', 'transformers');
+env.allowLocalModels = true;
+// 임베딩 파이프라인
+let embeddingPipeline = null;
+let embeddingReady = false;
+export async function initEmbedding() {
+    if (embeddingPipeline)
+        return;
+    try {
+        console.error('Loading embedding model (first time may take a while)...');
+        embeddingPipeline = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
+        embeddingReady = true;
+        console.error('Embedding model loaded successfully!');
+    }
+    catch (error) {
+        console.error('Failed to load embedding model:', error);
+    }
+}
+// 백그라운드에서 모델 로드 시작
+initEmbedding();
+export async function generateEmbedding(text) {
+    if (!embeddingPipeline) {
+        await initEmbedding();
+    }
+    if (!embeddingPipeline)
+        return null;
+    try {
+        const output = await embeddingPipeline(text, { pooling: 'mean', normalize: true });
+        return Array.from(output.data);
+    }
+    catch (error) {
+        console.error('Embedding generation error:', error);
+        return null;
+    }
+}
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+export function embeddingToBuffer(embedding) {
+    const float32Array = new Float32Array(embedding);
+    return Buffer.from(float32Array.buffer);
+}
+export function bufferToEmbedding(buffer) {
+    const float32Array = new Float32Array(buffer.buffer, buffer.byteOffset, buffer.length / 4);
+    return Array.from(float32Array);
+}
+export function isEmbeddingReady() {
+    return embeddingReady;
+}
+export function getEmbeddingPipeline() {
+    return embeddingPipeline;
+}

package/dist/utils/helpers.d.ts

@@ -0,0 +1,4 @@
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function readFileContent(filePath: string): Promise<string | null>;
+export declare function writeFileContent(filePath: string, content: string): Promise<void>;
+export declare function parseMarkdownTable(content: string, tableName: string): Record<string, string>;

package/dist/utils/helpers.js

@@ -0,0 +1,45 @@
+// 공통 유틸리티 함수
+import * as fs from 'fs/promises';
+import * as path from 'path';
+export async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function readFileContent(filePath) {
+    try {
+        return await fs.readFile(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeFileContent(filePath, content) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, 'utf-8');
+}
+export function parseMarkdownTable(content, tableName) {
+    const result = {};
+    const lines = content.split('\n');
+    let inTable = false;
+    for (const line of lines) {
+        if (line.includes(tableName)) {
+            inTable = true;
+            continue;
+        }
+        if (inTable && line.startsWith('|') && !line.includes('---')) {
+            const cells = line.split('|').map(c => c.trim()).filter(Boolean);
+            if (cells.length >= 2 && cells[0] !== '항목' && cells[0] !== '작업') {
+                result[cells[0]] = cells[1];
+            }
+        }
+        if (inTable && line.trim() === '') {
+            inTable = false;
+        }
+    }
+    return result;
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,17 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+declare class Logger {
+    private level;
+    private logFile;
+    constructor();
+    private shouldLog;
+    private maskSensitive;
+    private formatEntry;
+    private write;
+    debug(message: string, data?: Record<string, unknown>, tool?: string): void;
+    info(message: string, data?: Record<string, unknown>, tool?: string): void;
+    warn(message: string, data?: Record<string, unknown>, tool?: string): void;
+    error(message: string, data?: Record<string, unknown>, tool?: string): void;
+    withTool<T>(toolName: string, fn: () => Promise<T>, args?: Record<string, unknown>): Promise<T>;
+}
+export declare const logger: Logger;
+export {};