claude-session-continuity-mcp 1.0.0

package/dist/tools-v2/auto-capture.js

@@ -0,0 +1,252 @@
+// 자동 컨텍스트 캡처 도구
+// session_start, session_end 도구로 세션 라이프사이클 관리
+import { db } from '../db/database.js';
+import { logger } from '../utils/logger.js';
+import { loadContext, saveContext, createContextSnapshot, getCompactContext } from '../utils/auto-context.js';
+import { invalidateProjects } from '../utils/cache.js';
+import { z } from 'zod';
+// ===== 스키마 =====
+const SessionStartSchema = z.object({
+    project: z.string().min(1, 'project is required'),
+    compact: z.boolean().optional().default(false)
+});
+const SessionEndSchema = z.object({
+    project: z.string().min(1, 'project is required'),
+    currentState: z.string().min(1, 'currentState is required'),
+    recentFiles: z.array(z.string()).optional(),
+    blockers: z.string().optional(),
+    verification: z.enum(['passed', 'failed']).optional(),
+    architectureDecision: z.string().optional(),
+    codePattern: z.string().optional(),
+    techStack: z.record(z.string()).optional()
+});
+const SessionSummarySchema = z.object({
+    project: z.string().min(1, 'project is required')
+});
+// ===== 도구 정의 =====
+export const autoCaptureTools = [
+    {
+        name: 'session_start',
+        description: `세션 시작 시 자동 컨텍스트 로드. 새 세션의 첫 도구 호출.
+- 프로젝트 컨텍스트 자동 복원 (< 5ms 목표)
+- compact=true: 토큰 효율적 요약 (~650토큰)
+- compact=false: 전체 JSON 컨텍스트
+세션 시작 시 반드시 호출하여 연속성 확보.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: '프로젝트명' },
+                compact: { type: 'boolean', description: '간결한 요약 모드 (기본: false)', default: false }
+            },
+            required: ['project']
+        }
+    },
+    {
+        name: 'session_end',
+        description: `세션 종료 시 자동 컨텍스트 저장. 작업 완료 후 호출.
+- currentState: 현재 상태 1줄 요약 (필수)
+- recentFiles: 수정한 파일 목록 (최대 10개)
+- blockers: 발견한 블로커/이슈
+- verification: 마지막 검증 결과
+- architectureDecision: 새로운 아키텍처 결정
+- codePattern: 새로운 코드 패턴
+- techStack: 기술 스택 업데이트
+다음 세션에서 이 컨텍스트가 자동 복원됨.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: '프로젝트명' },
+                currentState: { type: 'string', description: '현재 상태 (1줄 요약)' },
+                recentFiles: { type: 'array', items: { type: 'string' }, description: '수정한 파일 목록' },
+                blockers: { type: 'string', description: '블로커/이슈' },
+                verification: { type: 'string', enum: ['passed', 'failed'], description: '검증 결과' },
+                architectureDecision: { type: 'string', description: '새 아키텍처 결정' },
+                codePattern: { type: 'string', description: '새 코드 패턴' },
+                techStack: { type: 'object', additionalProperties: { type: 'string' }, description: '기술 스택 업데이트' }
+            },
+            required: ['project', 'currentState']
+        }
+    },
+    {
+        name: 'session_summary',
+        description: `현재 프로젝트의 컨텍스트 요약 조회.
+- 토큰 추정치 포함
+- 전체 컨텍스트 스냅샷 반환
+세션 중간에 컨텍스트 확인 시 사용.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: '프로젝트명' }
+            },
+            required: ['project']
+        }
+    }
+];
+// ===== 핸들러 =====
+export async function handleSessionStart(args) {
+    return logger.withTool('session_start', async () => {
+        const parsed = SessionStartSchema.safeParse(args);
+        if (!parsed.success) {
+            return {
+                content: [{ type: 'text', text: `Validation error: ${parsed.error.message}` }],
+                isError: true
+            };
+        }
+        const { project, compact } = parsed.data;
+        const startTime = performance.now();
+        try {
+            // 세션 시작 기록
+            recordSessionStart(project);
+            if (compact) {
+                // 간결한 요약 반환
+                const summary = await getCompactContext(project);
+                const elapsed = performance.now() - startTime;
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `${summary}\n\n---\n_Loaded in ${elapsed.toFixed(2)}ms_`
+                        }]
+                };
+            }
+            // 전체 컨텍스트 반환
+            const context = await loadContext(project);
+            const elapsed = performance.now() - startTime;
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            ...context,
+                            _meta: {
+                                loadTimeMs: parseFloat(elapsed.toFixed(2)),
+                                timestamp: new Date().toISOString()
+                            }
+                        }, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            logger.error('Session start failed', { project, error: String(error) });
+            return {
+                content: [{ type: 'text', text: `Session start failed: ${error}` }],
+                isError: true
+            };
+        }
+    }, args);
+}
+export async function handleSessionEnd(args) {
+    return logger.withTool('session_end', async () => {
+        const parsed = SessionEndSchema.safeParse(args);
+        if (!parsed.success) {
+            return {
+                content: [{ type: 'text', text: `Validation error: ${parsed.error.message}` }],
+                isError: true
+            };
+        }
+        const { project, currentState, recentFiles, blockers, verification, architectureDecision, codePattern, techStack } = parsed.data;
+        try {
+            // 컨텍스트 저장
+            await saveContext(project, {
+                currentState,
+                recentFiles,
+                blockers,
+                verification,
+                architectureDecision,
+                codePattern,
+                techStack
+            });
+            // 세션 종료 기록
+            recordSessionEnd(project, currentState, verification);
+            // 스냅샷 생성 (토큰 추정 포함)
+            const snapshot = await createContextSnapshot(project);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            project,
+                            saved: {
+                                currentState,
+                                recentFilesCount: recentFiles?.length || 0,
+                                hasBlockers: !!blockers,
+                                verification: verification || null,
+                                newDecision: !!architectureDecision,
+                                newPattern: !!codePattern,
+                                techStackUpdated: !!techStack
+                            },
+                            tokenEstimate: snapshot.tokenEstimate,
+                            timestamp: snapshot.timestamp
+                        }, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            logger.error('Session end failed', { project, error: String(error) });
+            return {
+                content: [{ type: 'text', text: `Session end failed: ${error}` }],
+                isError: true
+            };
+        }
+    }, args);
+}
+export async function handleSessionSummary(args) {
+    return logger.withTool('session_summary', async () => {
+        const parsed = SessionSummarySchema.safeParse(args);
+        if (!parsed.success) {
+            return {
+                content: [{ type: 'text', text: `Validation error: ${parsed.error.message}` }],
+                isError: true
+            };
+        }
+        const { project } = parsed.data;
+        try {
+            const snapshot = await createContextSnapshot(project);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(snapshot, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            logger.error('Session summary failed', { project, error: String(error) });
+            return {
+                content: [{ type: 'text', text: `Session summary failed: ${error}` }],
+                isError: true
+            };
+        }
+    }, args);
+}
+// ===== 세션 기록 헬퍼 =====
+function recordSessionStart(project) {
+    try {
+        const stmt = db.prepare(`
+      INSERT INTO sessions (project, last_work, current_status)
+      VALUES (?, 'Session started', 'in_progress')
+    `);
+        stmt.run(project);
+        invalidateProjects();
+    }
+    catch (error) {
+        logger.warn('Failed to record session start', { project, error: String(error) });
+    }
+}
+function recordSessionEnd(project, lastWork, verification) {
+    try {
+        // 마지막 in_progress 세션 업데이트
+        const stmt = db.prepare(`
+      UPDATE sessions
+      SET last_work = ?,
+          current_status = 'completed',
+          verification_result = ?,
+          timestamp = CURRENT_TIMESTAMP
+      WHERE project = ? AND current_status = 'in_progress'
+      ORDER BY id DESC
+      LIMIT 1
+    `);
+        stmt.run(lastWork, verification || null, project);
+        invalidateProjects();
+    }
+    catch (error) {
+        logger.warn('Failed to record session end', { project, error: String(error) });
+    }
+}

package/dist/tools-v2/context.d.ts

@@ -0,0 +1,4 @@
+import type { Tool, CallToolResult } from '../types.js';
+export declare const contextTools: Tool[];
+export declare function handleContextGet(args: unknown): Promise<CallToolResult>;
+export declare function handleContextUpdate(args: unknown): Promise<CallToolResult>;

package/dist/tools-v2/context.js

@@ -0,0 +1,170 @@
+// 컨텍스트 도구 (context_get, context_update)
+// 프로젝트 연속성의 핵심 - 세션 간 컨텍스트 유지
+import * as path from 'path';
+import { db, APPS_DIR } from '../db/database.js';
+import { readFileContent, parseMarkdownTable } from '../utils/helpers.js';
+import { logger } from '../utils/logger.js';
+import { ContextGetSchema, ContextUpdateSchema } from '../schemas.js';
+// ===== 도구 정의 =====
+export const contextTools = [
+    {
+        name: 'context_get',
+        description: `프로젝트 컨텍스트 조회. 새 세션 시작 시 필수 호출.
+- 고정 컨텍스트: 기술 스택, 아키텍처 결정, 코드 패턴
+- 활성 컨텍스트: 현재 상태, 최근 파일, 블로커
+- 미완료 태스크 (최대 3개)
+~650토큰으로 압축된 프로젝트 정보 반환.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: '프로젝트명' }
+            },
+            required: ['project']
+        }
+    },
+    {
+        name: 'context_update',
+        description: `프로젝트 컨텍스트 업데이트. 작업 종료 시 호출.
+- currentState: 현재 상태 1줄 요약 (필수)
+- recentFiles: 최근 수정 파일 (최대 10개)
+- blockers: 블로커/이슈 (없으면 생략)
+- verification: 마지막 검증 결과 (passed/failed)
+- architectureDecision: 새로운 아키텍처 결정`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: '프로젝트명' },
+                currentState: { type: 'string', description: '현재 상태 (1줄 요약)' },
+                recentFiles: { type: 'array', items: { type: 'string' }, description: '최근 수정 파일' },
+                blockers: { type: 'string', description: '블로커/이슈' },
+                verification: { type: 'string', enum: ['passed', 'failed'], description: '검증 결과' },
+                architectureDecision: { type: 'string', description: '추가할 아키텍처 결정' }
+            },
+            required: ['project', 'currentState']
+        }
+    }
+];
+// ===== 핸들러 =====
+export async function handleContextGet(args) {
+    return logger.withTool('context_get', async () => {
+        // 입력 검증
+        const parsed = ContextGetSchema.safeParse(args);
+        if (!parsed.success) {
+            return {
+                content: [{ type: 'text', text: `Validation error: ${parsed.error.message}` }],
+                isError: true
+            };
+        }
+        const { project } = parsed.data;
+        // 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);
+        // 고정 컨텍스트가 없으면 plan.md에서 자동 추출
+        let techStack = {};
+        if (!projectContext) {
+            const planPath = path.join(APPS_DIR, project, 'plan.md');
+            const planContent = await readFileContent(planPath);
+            if (planContent) {
+                techStack = parseMarkdownTable(planContent, '기술 스택');
+            }
+        }
+        const result = {
+            project,
+            fixed: {
+                techStack: projectContext?.tech_stack ? JSON.parse(projectContext.tech_stack) : techStack,
+                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.map(t => ({
+                id: t.id,
+                title: t.title,
+                status: t.status,
+                priority: t.priority
+            }))
+        };
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }]
+        };
+    }, args);
+}
+export async function handleContextUpdate(args) {
+    return logger.withTool('context_update', async () => {
+        // 입력 검증
+        const parsed = ContextUpdateSchema.safeParse(args);
+        if (!parsed.success) {
+            return {
+                content: [{ type: 'text', text: `Validation error: ${parsed.error.message}` }],
+                isError: true
+            };
+        }
+        const { project, currentState, recentFiles, blockers, verification, architectureDecision } = parsed.data;
+        // 활성 컨텍스트 업데이트
+        const stmt = db.prepare(`
+      INSERT OR REPLACE INTO active_context (project, current_state, recent_files, blockers, last_verification, updated_at)
+      VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+    `);
+        stmt.run(project, currentState, recentFiles ? JSON.stringify(recentFiles.slice(0, 10)) : null, blockers || null, verification || null);
+        // 아키텍처 결정 추가 (있으면)
+        if (architectureDecision) {
+            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 */ }
+            }
+            decisions.unshift(architectureDecision);
+            decisions = decisions.slice(0, 5);
+            const updateStmt = 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 decisionsJson = JSON.stringify(decisions);
+            updateStmt.run(project, decisionsJson, decisionsJson);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        project,
+                        updated: {
+                            currentState,
+                            recentFiles: recentFiles?.length || 0,
+                            hasBlockers: !!blockers,
+                            verification: verification || null,
+                            architectureDecision: architectureDecision || null
+                        }
+                    })
+                }]
+        };
+    }, args);
+}

package/dist/tools-v2/embedding.d.ts

@@ -0,0 +1,3 @@
+import type { Tool, CallToolResult } from '../types.js';
+export declare const embeddingTools: Tool[];
+export declare function handleRebuildEmbeddings(args: unknown): Promise<CallToolResult>;

package/dist/tools-v2/embedding.js

@@ -0,0 +1,115 @@
+// 임베딩 도구 (rebuild_embeddings)
+// 시맨틱 검색용 임베딩 관리
+import { db } from '../db/database.js';
+import { generateEmbedding, embeddingToBuffer } from '../utils/embedding.js';
+import { logger } from '../utils/logger.js';
+// ===== 도구 정의 =====
+export const embeddingTools = [
+    {
+        name: 'rebuild_embeddings',
+        description: `임베딩 재생성.
+- force=false: 누락된 임베딩만 생성
+- force=true: 전체 임베딩 재생성
+
+시맨틱 검색 품질 개선에 사용.
+배치 처리로 메모리 효율적.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                force: { type: 'boolean', description: '전체 재생성 (기본: false)' }
+            }
+        }
+    }
+];
+// ===== 핸들러 =====
+export async function handleRebuildEmbeddings(args) {
+    return logger.withTool('rebuild_embeddings', async () => {
+        const force = args?.force || false;
+        // 대상 메모리 조회
+        let sql;
+        if (force) {
+            sql = 'SELECT id, content FROM memories ORDER BY id';
+        }
+        else {
+            sql = `
+        SELECT m.id, m.content FROM memories m
+        LEFT JOIN embeddings e ON m.id = e.memory_id
+        WHERE e.memory_id IS NULL
+        ORDER BY m.id
+      `;
+        }
+        const memories = db.prepare(sql).all();
+        if (memories.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'No embeddings to rebuild',
+                            processed: 0
+                        })
+                    }]
+            };
+        }
+        logger.info('Starting embedding rebuild', {
+            total: memories.length,
+            force
+        }, 'rebuild_embeddings');
+        // 배치 처리
+        const BATCH_SIZE = 10;
+        let processed = 0;
+        let failed = 0;
+        for (let i = 0; i < memories.length; i += BATCH_SIZE) {
+            const batch = memories.slice(i, i + BATCH_SIZE);
+            await Promise.all(batch.map(async (memory) => {
+                try {
+                    const embedding = await generateEmbedding(memory.content);
+                    if (embedding) {
+                        const stmt = db.prepare(`
+              INSERT OR REPLACE INTO embeddings (memory_id, embedding, created_at)
+              VALUES (?, ?, CURRENT_TIMESTAMP)
+            `);
+                        stmt.run(memory.id, embeddingToBuffer(embedding));
+                        processed++;
+                    }
+                    else {
+                        failed++;
+                    }
+                }
+                catch (e) {
+                    failed++;
+                    logger.error('Embedding generation failed', {
+                        memoryId: memory.id,
+                        error: String(e)
+                    }, 'rebuild_embeddings');
+                }
+            }));
+            // 진행 상황 로깅
+            if ((i + BATCH_SIZE) % 50 === 0 || i + BATCH_SIZE >= memories.length) {
+                logger.info('Embedding progress', {
+                    processed,
+                    failed,
+                    remaining: memories.length - i - BATCH_SIZE
+                }, 'rebuild_embeddings');
+            }
+        }
+        // 최종 통계
+        const totalMemories = db.prepare('SELECT COUNT(*) as count FROM memories').get().count;
+        const totalEmbeddings = db.prepare('SELECT COUNT(*) as count FROM embeddings').get().count;
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        success: true,
+                        processed,
+                        failed,
+                        coverage: `${Math.round((totalEmbeddings / totalMemories) * 100)}%`,
+                        stats: {
+                            totalMemories,
+                            totalEmbeddings
+                        }
+                    })
+                }]
+        };
+    }, args);
+}

package/dist/tools-v2/index.d.ts

@@ -0,0 +1,13 @@
+import { handleContextGet, handleContextUpdate } from './context.js';
+import { handleMemoryStore, handleMemorySearch, handleMemoryDelete, handleMemoryStats } from './memory.js';
+import { handleTaskManage } from './task.js';
+import { handleVerify } from './verify.js';
+import { handleLearn, handleRecallSolution } from './learn.js';
+import { handleProjects } from './projects.js';
+import { handleRebuildEmbeddings } from './embedding.js';
+import { handleSessionStart, handleSessionEnd, handleSessionSummary } from './auto-capture.js';
+import type { Tool, CallToolResult } from '../types.js';
+export declare const allToolsV2: Tool[];
+export declare function handleToolV2(name: string, args: unknown): Promise<CallToolResult>;
+export declare const toolNamesV2: string[];
+export { handleContextGet, handleContextUpdate, handleMemoryStore, handleMemorySearch, handleMemoryDelete, handleMemoryStats, handleTaskManage, handleVerify, handleLearn, handleRecallSolution, handleProjects, handleRebuildEmbeddings, handleSessionStart, handleSessionEnd, handleSessionSummary };

package/dist/tools-v2/index.js

@@ -0,0 +1,73 @@
+// 통합 도구 v2 - 15개 도구
+// 기존 46개 도구를 15개로 통합 (자동 컨텍스트 캡처 3개 추가)
+import { contextTools, handleContextGet, handleContextUpdate } from './context.js';
+import { memoryTools, handleMemoryStore, handleMemorySearch, handleMemoryDelete, handleMemoryStats } from './memory.js';
+import { taskTools, handleTaskManage } from './task.js';
+import { verifyTools, handleVerify } from './verify.js';
+import { learnTools, handleLearn, handleRecallSolution } from './learn.js';
+import { projectsTools, handleProjects } from './projects.js';
+import { embeddingTools, handleRebuildEmbeddings } from './embedding.js';
+import { autoCaptureTools, handleSessionStart, handleSessionEnd, handleSessionSummary } from './auto-capture.js';
+// 모든 도구 정의 (15개)
+export const allToolsV2 = [
+    ...contextTools, // context_get, context_update
+    ...memoryTools, // memory_store, memory_search, memory_delete, memory_stats
+    ...taskTools, // task_manage
+    ...verifyTools, // verify
+    ...learnTools, // learn, recall_solution
+    ...projectsTools, // projects
+    ...embeddingTools, // rebuild_embeddings
+    ...autoCaptureTools // session_start, session_end, session_summary
+];
+// 도구 핸들러 라우터
+export async function handleToolV2(name, args) {
+    switch (name) {
+        // Context
+        case 'context_get':
+            return handleContextGet(args);
+        case 'context_update':
+            return handleContextUpdate(args);
+        // Memory
+        case 'memory_store':
+            return handleMemoryStore(args);
+        case 'memory_search':
+            return handleMemorySearch(args);
+        case 'memory_delete':
+            return handleMemoryDelete(args);
+        case 'memory_stats':
+            return handleMemoryStats();
+        // Task
+        case 'task_manage':
+            return handleTaskManage(args);
+        // Verify
+        case 'verify':
+            return handleVerify(args);
+        // Learn
+        case 'learn':
+            return handleLearn(args);
+        case 'recall_solution':
+            return handleRecallSolution(args);
+        // Projects
+        case 'projects':
+            return handleProjects(args);
+        // Embedding
+        case 'rebuild_embeddings':
+            return handleRebuildEmbeddings(args);
+        // Auto Capture (Session Lifecycle)
+        case 'session_start':
+            return handleSessionStart(args);
+        case 'session_end':
+            return handleSessionEnd(args);
+        case 'session_summary':
+            return handleSessionSummary(args);
+        default:
+            return {
+                content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                isError: true
+            };
+    }
+}
+// 도구 이름 목록
+export const toolNamesV2 = allToolsV2.map(t => t.name);
+// Export individual handlers for testing
+export { handleContextGet, handleContextUpdate, handleMemoryStore, handleMemorySearch, handleMemoryDelete, handleMemoryStats, handleTaskManage, handleVerify, handleLearn, handleRecallSolution, handleProjects, handleRebuildEmbeddings, handleSessionStart, handleSessionEnd, handleSessionSummary };

package/dist/tools-v2/learn.d.ts

@@ -0,0 +1,4 @@
+import type { Tool, CallToolResult } from '../types.js';
+export declare const learnTools: Tool[];
+export declare function handleLearn(args: unknown): Promise<CallToolResult>;
+export declare function handleRecallSolution(args: unknown): Promise<CallToolResult>;