claude-session-continuity-mcp 1.0.0

package/dist/tools/filter.js

@@ -0,0 +1,169 @@
+// Content Filtering 학습/회피 도구 (3개)
+import { db, contentFilterPatterns, loadContentFilterPatterns } from '../db/database.js';
+// ===== 도구 정의 =====
+export const filterTools = [
+    {
+        name: 'record_filter_pattern',
+        description: 'API content filtering에 걸린 패턴을 기록합니다. 비슷한 상황 회피에 사용됩니다.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                patternType: {
+                    type: 'string',
+                    enum: ['code_block', 'file_content', 'long_output', 'sensitive_keyword', 'binary_like', 'other'],
+                    description: '패턴 유형'
+                },
+                patternDescription: { type: 'string', description: '어떤 상황에서 발생했는지 설명' },
+                fileExtension: { type: 'string', description: '관련 파일 확장자 (선택, 예: .kt, .tsx)' },
+                exampleContext: { type: 'string', description: '발생 컨텍스트 예시 (민감 정보 제외)' },
+                mitigationStrategy: { type: 'string', description: '회피 전략 (예: 청크 분할, 요약만 출력)' }
+            },
+            required: ['patternType', 'patternDescription']
+        }
+    },
+    {
+        name: 'get_filter_patterns',
+        description: '기록된 content filtering 패턴 목록을 조회합니다. 응답 생성 시 참고용.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                patternType: { type: 'string', description: '패턴 유형 필터 (선택)' },
+                fileExtension: { type: 'string', description: '파일 확장자 필터 (선택)' }
+            }
+        }
+    },
+    {
+        name: 'get_safe_output_guidelines',
+        description: '현재 학습된 패턴 기반으로 안전한 출력 가이드라인을 반환합니다.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                context: { type: 'string', description: '현재 작업 컨텍스트 (예: kotlin 파일 분석, 긴 코드 출력)' }
+            }
+        }
+    }
+];
+// ===== 핸들러 =====
+export function recordFilterPattern(patternType, patternDescription, fileExtension, exampleContext, mitigationStrategy) {
+    try {
+        // 기존 패턴 확인
+        const existingStmt = db.prepare(`
+      SELECT id, occurrence_count FROM content_filter_patterns
+      WHERE pattern_type = ? AND pattern_description = ?
+    `);
+        const existing = existingStmt.get(patternType, patternDescription);
+        if (existing) {
+            const updateStmt = db.prepare(`
+        UPDATE content_filter_patterns
+        SET occurrence_count = ?, last_occurred = CURRENT_TIMESTAMP
+        WHERE id = ?
+      `);
+            updateStmt.run(existing.occurrence_count + 1, existing.id);
+            // 캐시 갱신
+            loadContentFilterPatterns();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            updated: true,
+                            id: existing.id,
+                            occurrenceCount: existing.occurrence_count + 1
+                        })
+                    }]
+            };
+        }
+        else {
+            const insertStmt = db.prepare(`
+        INSERT INTO content_filter_patterns (pattern_type, pattern_description, file_extension, example_context, mitigation_strategy)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+            const result = insertStmt.run(patternType, patternDescription, fileExtension || null, exampleContext || null, mitigationStrategy || null);
+            // 캐시 갱신
+            loadContentFilterPatterns();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            created: true,
+                            id: result.lastInsertRowid
+                        })
+                    }]
+            };
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true
+        };
+    }
+}
+export function getFilterPatterns(patternType, fileExtension) {
+    try {
+        let filtered = contentFilterPatterns;
+        if (patternType) {
+            filtered = filtered.filter(p => p.patternType === patternType);
+        }
+        if (fileExtension) {
+            filtered = filtered.filter(p => p.fileExtension === fileExtension);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        found: filtered.length,
+                        patterns: filtered
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true
+        };
+    }
+}
+export function getSafeOutputGuidelines(context) {
+    try {
+        const guidelines = [
+            '1. 긴 코드 출력 시 청크로 분할 (500줄 이하)',
+            '2. 파일 전체 읽기보다 특정 섹션만 Read (offset, limit 사용)',
+            '3. 불완전한 Edit 작업 후 남은 코드 정리',
+            '4. 민감할 수 있는 키워드 피하기'
+        ];
+        // 컨텍스트에 맞는 추가 가이드라인
+        if (context) {
+            const contextLower = context.toLowerCase();
+            if (contextLower.includes('kotlin') || contextLower.includes('.kt')) {
+                guidelines.push('5. Kotlin 파일: 긴 클래스는 메서드별로 분석');
+            }
+            if (contextLower.includes('긴') || contextLower.includes('long')) {
+                guidelines.push('5. 긴 출력: 요약 먼저 제공, 상세 내용은 요청 시');
+            }
+        }
+        // 학습된 패턴 기반 추가 가이드라인
+        const patternGuidelines = contentFilterPatterns
+            .filter(p => p.mitigationStrategy)
+            .slice(0, 3)
+            .map((p, i) => `${guidelines.length + i + 1}. ${p.mitigationStrategy}`);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        context: context || 'general',
+                        guidelines: [...guidelines, ...patternGuidelines],
+                        learnedPatternsCount: contentFilterPatterns.length
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true
+        };
+    }
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,12 @@
+export * from './project.js';
+export * from './session.js';
+export * from './memory.js';
+export * from './embedding.js';
+export * from './relation.js';
+export * from './feedback.js';
+export * from './filter.js';
+export * from './learning.js';
+export * from './context.js';
+export * from './task.js';
+export * from './solution.js';
+export declare const allTools: import("../types.js").Tool[];

package/dist/tools/index.js

@@ -0,0 +1,38 @@
+// 모든 도구를 내보내는 인덱스 파일
+export * from './project.js';
+export * from './session.js';
+export * from './memory.js';
+export * from './embedding.js';
+export * from './relation.js';
+export * from './feedback.js';
+export * from './filter.js';
+export * from './learning.js';
+export * from './context.js';
+export * from './task.js';
+export * from './solution.js';
+// 도구 정의 배열들
+import { projectTools } from './project.js';
+import { sessionTools } from './session.js';
+import { memoryTools } from './memory.js';
+import { embeddingTools } from './embedding.js';
+import { relationTools } from './relation.js';
+import { feedbackTools } from './feedback.js';
+import { filterTools } from './filter.js';
+import { learningTools } from './learning.js';
+import { contextTools } from './context.js';
+import { taskTools } from './task.js';
+import { solutionTools } from './solution.js';
+// 모든 도구 통합
+export const allTools = [
+    ...projectTools,
+    ...sessionTools,
+    ...memoryTools,
+    ...embeddingTools,
+    ...relationTools,
+    ...feedbackTools,
+    ...filterTools,
+    ...learningTools,
+    ...contextTools,
+    ...taskTools,
+    ...solutionTools
+];

package/dist/tools/learning.d.ts

@@ -0,0 +1,8 @@
+import type { Tool, CallToolResult, AutoLearnDecisionArgs, AutoLearnFixArgs, AutoLearnPatternArgs, AutoLearnDependencyArgs } from '../types.js';
+export declare const learningTools: Tool[];
+export declare function autoLearnDecision(args: AutoLearnDecisionArgs): Promise<CallToolResult>;
+export declare function autoLearnFix(args: AutoLearnFixArgs): Promise<CallToolResult>;
+export declare function autoLearnPattern(args: AutoLearnPatternArgs): Promise<CallToolResult>;
+export declare function autoLearnDependency(args: AutoLearnDependencyArgs): Promise<CallToolResult>;
+export declare function getProjectKnowledge(project: string, knowledgeType?: string, limit?: number): CallToolResult;
+export declare function getSimilarIssues(errorOrIssue: string, project?: string, limit?: number): Promise<CallToolResult>;

package/dist/tools/learning.js

@@ -0,0 +1,395 @@
+// 자동 학습 시스템 도구 (6개)
+import { db } from '../db/database.js';
+import { generateEmbedding, embeddingToBuffer, getEmbeddingPipeline } from '../utils/embedding.js';
+import { semanticSearch } from './embedding.js';
+// ===== 도구 정의 =====
+export const learningTools = [
+    {
+        name: 'auto_learn_decision',
+        description: '아키텍처/기술 결정 사항을 자동 기록합니다. 왜 이 선택을 했는지 기록하여 나중에 참조할 수 있습니다.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: '프로젝트명' },
+                decision: { type: 'string', description: '결정 내용 (예: Socket.IO 대신 WebSocket 사용)' },
+                reason: { type: 'string', description: '결정 이유' },
+                context: { type: 'string', description: '결정 배경/맥락' },
+                alternatives: { type: 'array', items: { type: 'string' }, description: '고려했던 대안들' },
+                files: { type: 'array', items: { type: 'string' }, description: '관련 파일들' }
+            },
+            required: ['project', 'decision', 'reason']
+        }
+    },
+    {
+        name: 'auto_learn_fix',
+        description: '에러/버그 해결 방법을 자동 기록합니다. 비슷한 에러 발생 시 참조할 수 있습니다.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: '프로젝트명' },
+                error: { type: 'string', description: '에러 메시지 또는 증상' },
+                cause: { type: 'string', description: '원인 (선택)' },
+                solution: { type: 'string', description: '해결 방법' },
+                files: { type: 'array', items: { type: 'string' }, description: '수정한 파일들' },
+                preventionTip: { type: 'string', description: '재발 방지 팁 (선택)' }
+            },
+            required: ['project', 'error', 'solution']
+        }
+    },
+    {
+        name: 'auto_learn_pattern',
+        description: '프로젝트의 코드 패턴/컨벤션을 자동 기록합니다. 일관성 유지에 활용됩니다.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: '프로젝트명' },
+                patternName: { type: 'string', description: '패턴 이름 (예: Repository 패턴, State hoisting)' },
+                description: { type: 'string', description: '패턴 설명' },
+                example: { type: 'string', description: '예시 코드나 파일 경로' },
+                appliesTo: { type: 'string', description: '적용 대상 (예: 모든 Repository, Compose UI)' }
+            },
+            required: ['project', 'patternName', 'description']
+        }
+    },
+    {
+        name: 'auto_learn_dependency',
+        description: '의존성 변경 사항을 자동 기록합니다. 버전 충돌이나 업그레이드 시 참조합니다.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: '프로젝트명' },
+                dependency: { type: 'string', description: '의존성 이름' },
+                action: { type: 'string', enum: ['add', 'remove', 'upgrade', 'downgrade'], description: '작업 유형' },
+                fromVersion: { type: 'string', description: '이전 버전 (선택)' },
+                toVersion: { type: 'string', description: '새 버전 (선택)' },
+                reason: { type: 'string', description: '변경 이유' },
+                breakingChanges: { type: 'string', description: 'Breaking changes 내용 (선택)' }
+            },
+            required: ['project', 'dependency', 'action', 'reason']
+        }
+    },
+    {
+        name: 'get_project_knowledge',
+        description: '프로젝트에서 학습된 모든 지식을 조회합니다. 결정, 해결, 패턴, 의존성 변경 등.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project: { type: 'string', description: '프로젝트명' },
+                knowledgeType: {
+                    type: 'string',
+                    enum: ['all', 'decision', 'fix', 'pattern', 'dependency'],
+                    description: '지식 유형 필터 (기본: all)'
+                },
+                limit: { type: 'number', description: '최대 결과 수 (기본: 20)' }
+            },
+            required: ['project']
+        }
+    },
+    {
+        name: 'get_similar_issues',
+        description: '비슷한 에러/이슈의 해결 방법을 검색합니다. 시맨틱 검색으로 유사한 문제를 찾습니다.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                errorOrIssue: { type: 'string', description: '에러 메시지 또는 이슈 설명' },
+                project: { type: 'string', description: '특정 프로젝트에서만 검색 (선택)' },
+                limit: { type: 'number', description: '최대 결과 수 (기본: 5)' }
+            },
+            required: ['errorOrIssue']
+        }
+    }
+];
+// ===== 핸들러 =====
+export async function autoLearnDecision(args) {
+    try {
+        const content = `[DECISION] ${args.decision}\n이유: ${args.reason}${args.context ? `\n맥락: ${args.context}` : ''}${args.alternatives?.length ? `\n대안들: ${args.alternatives.join(', ')}` : ''}`;
+        const stmt = db.prepare(`
+      INSERT INTO memories (content, memory_type, tags, project, importance, metadata)
+      VALUES (?, 'decision', ?, ?, 7, ?)
+    `);
+        const tags = JSON.stringify(['auto-learn', 'architecture', 'decision']);
+        const metadata = JSON.stringify({
+            type: 'decision',
+            alternatives: args.alternatives,
+            files: args.files
+        });
+        const result = stmt.run(content, tags, args.project, metadata);
+        const memoryId = result.lastInsertRowid;
+        // 임베딩 생성
+        generateEmbedding(content).then(embedding => {
+            if (embedding) {
+                const embStmt = db.prepare('INSERT OR REPLACE INTO embeddings (memory_id, embedding) VALUES (?, ?)');
+                embStmt.run(memoryId, embeddingToBuffer(embedding));
+            }
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ success: true, id: memoryId, type: 'decision' })
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true
+        };
+    }
+}
+export async function autoLearnFix(args) {
+    try {
+        const content = `[FIX] ${args.error}\n해결: ${args.solution}${args.cause ? `\n원인: ${args.cause}` : ''}${args.preventionTip ? `\n예방: ${args.preventionTip}` : ''}`;
+        const stmt = db.prepare(`
+      INSERT INTO memories (content, memory_type, tags, project, importance, metadata)
+      VALUES (?, 'error', ?, ?, 8, ?)
+    `);
+        const tags = JSON.stringify(['auto-learn', 'fix', 'error-solution']);
+        const metadata = JSON.stringify({
+            type: 'fix',
+            error: args.error,
+            solution: args.solution,
+            cause: args.cause,
+            files: args.files,
+            preventionTip: args.preventionTip
+        });
+        const result = stmt.run(content, tags, args.project, metadata);
+        const memoryId = result.lastInsertRowid;
+        // 임베딩 생성
+        generateEmbedding(content).then(embedding => {
+            if (embedding) {
+                const embStmt = db.prepare('INSERT OR REPLACE INTO embeddings (memory_id, embedding) VALUES (?, ?)');
+                embStmt.run(memoryId, embeddingToBuffer(embedding));
+            }
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ success: true, id: memoryId, type: 'fix' })
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true
+        };
+    }
+}
+export async function autoLearnPattern(args) {
+    try {
+        const content = `[PATTERN] ${args.patternName}\n설명: ${args.description}${args.example ? `\n예시: ${args.example}` : ''}${args.appliesTo ? `\n적용대상: ${args.appliesTo}` : ''}`;
+        const stmt = db.prepare(`
+      INSERT INTO memories (content, memory_type, tags, project, importance, metadata)
+      VALUES (?, 'pattern', ?, ?, 6, ?)
+    `);
+        const tags = JSON.stringify(['auto-learn', 'code-pattern', 'convention']);
+        const metadata = JSON.stringify({
+            type: 'pattern',
+            patternName: args.patternName,
+            appliesTo: args.appliesTo
+        });
+        const result = stmt.run(content, tags, args.project, metadata);
+        const memoryId = result.lastInsertRowid;
+        // 임베딩 생성
+        generateEmbedding(content).then(embedding => {
+            if (embedding) {
+                const embStmt = db.prepare('INSERT OR REPLACE INTO embeddings (memory_id, embedding) VALUES (?, ?)');
+                embStmt.run(memoryId, embeddingToBuffer(embedding));
+            }
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ success: true, id: memoryId, type: 'pattern' })
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true
+        };
+    }
+}
+export async function autoLearnDependency(args) {
+    try {
+        const versionInfo = args.fromVersion && args.toVersion
+            ? `${args.fromVersion} → ${args.toVersion}`
+            : args.toVersion || args.fromVersion || '';
+        const content = `[DEPENDENCY] ${args.action.toUpperCase()} ${args.dependency} ${versionInfo}\n이유: ${args.reason}${args.breakingChanges ? `\nBreaking Changes: ${args.breakingChanges}` : ''}`;
+        const stmt = db.prepare(`
+      INSERT INTO memories (content, memory_type, tags, project, importance, metadata)
+      VALUES (?, 'learning', ?, ?, 5, ?)
+    `);
+        const tags = JSON.stringify(['auto-learn', 'dependency', args.action]);
+        const metadata = JSON.stringify({
+            type: 'dependency',
+            dependency: args.dependency,
+            action: args.action,
+            fromVersion: args.fromVersion,
+            toVersion: args.toVersion,
+            breakingChanges: args.breakingChanges
+        });
+        const result = stmt.run(content, tags, args.project, metadata);
+        const memoryId = result.lastInsertRowid;
+        // 임베딩 생성
+        generateEmbedding(content).then(embedding => {
+            if (embedding) {
+                const embStmt = db.prepare('INSERT OR REPLACE INTO embeddings (memory_id, embedding) VALUES (?, ?)');
+                embStmt.run(memoryId, embeddingToBuffer(embedding));
+            }
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ success: true, id: memoryId, type: 'dependency' })
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true
+        };
+    }
+}
+export function getProjectKnowledge(project, knowledgeType = 'all', limit = 20) {
+    try {
+        let sql = `
+      SELECT id, content, memory_type, tags, importance, metadata, created_at
+      FROM memories
+      WHERE project = ?
+      AND tags LIKE '%"auto-learn"%'
+    `;
+        const params = [project];
+        if (knowledgeType !== 'all') {
+            const typeMap = {
+                decision: 'decision',
+                fix: 'error',
+                pattern: 'pattern',
+                dependency: 'learning'
+            };
+            sql += ` AND memory_type = ?`;
+            params.push(typeMap[knowledgeType] || knowledgeType);
+        }
+        sql += ` ORDER BY importance DESC, created_at DESC LIMIT ?`;
+        params.push(limit);
+        const stmt = db.prepare(sql);
+        const rows = stmt.all(...params);
+        const knowledge = rows.map(row => {
+            let meta = {};
+            try {
+                meta = JSON.parse(row.metadata || '{}');
+            }
+            catch { }
+            return {
+                id: row.id,
+                type: meta.type || row.memory_type,
+                content: row.content,
+                importance: row.importance,
+                createdAt: row.created_at,
+                metadata: meta
+            };
+        });
+        // 유형별 통계
+        const stats = {
+            decision: knowledge.filter(k => k.type === 'decision').length,
+            fix: knowledge.filter(k => k.type === 'fix').length,
+            pattern: knowledge.filter(k => k.type === 'pattern').length,
+            dependency: knowledge.filter(k => k.type === 'dependency').length
+        };
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        project,
+                        totalKnowledge: knowledge.length,
+                        stats,
+                        knowledge: knowledge.slice(0, limit)
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true
+        };
+    }
+}
+export async function getSimilarIssues(errorOrIssue, project, limit = 5) {
+    try {
+        // 먼저 시맨틱 검색 시도
+        if (getEmbeddingPipeline()) {
+            const result = await semanticSearch(errorOrIssue, limit, 0.3, 'error', project);
+            const resultText = JSON.parse(result.content[0].text);
+            if (resultText.found > 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                searchType: 'semantic',
+                                query: errorOrIssue.substring(0, 100),
+                                found: resultText.found,
+                                solutions: resultText.results.map((r) => ({
+                                    id: r.id,
+                                    similarity: r.similarity,
+                                    content: r.content,
+                                    project: r.project
+                                }))
+                            }, null, 2)
+                        }]
+                };
+            }
+        }
+        // 시맨틱 검색 결과 없으면 FTS 검색
+        const keywords = errorOrIssue.split(/\s+/).filter(w => w.length > 3).slice(0, 5);
+        const ftsQuery = keywords.join(' OR ');
+        let query = `
+      SELECT m.id, m.content, m.project, m.metadata
+      FROM memories_fts fts
+      JOIN memories m ON m.id = fts.rowid
+      WHERE memories_fts MATCH ?
+      AND m.memory_type = 'error'
+    `;
+        const params = [ftsQuery];
+        if (project) {
+            query += ` AND m.project = ?`;
+            params.push(project);
+        }
+        query += ` LIMIT ?`;
+        params.push(limit);
+        const stmt = db.prepare(query);
+        const rows = stmt.all(...params);
+        const solutions = rows.map(row => {
+            let metadata = {};
+            try {
+                metadata = JSON.parse(row.metadata || '{}');
+            }
+            catch { }
+            return {
+                id: row.id,
+                content: row.content,
+                project: row.project,
+                solution: metadata.solution
+            };
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        searchType: 'fts',
+                        query: errorOrIssue.substring(0, 100),
+                        found: solutions.length,
+                        solutions
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}` }],
+            isError: true
+        };
+    }
+}

package/dist/tools/memory.d.ts

@@ -0,0 +1,8 @@
+import type { Tool, CallToolResult } from '../types.js';
+export declare const memoryTools: Tool[];
+export declare function storeMemory(content: string, memoryType: string, tags?: string[], project?: string, importance?: number, metadata?: Record<string, unknown>): Promise<CallToolResult>;
+export declare function recallMemory(query: string, memoryType?: string, project?: string, limit?: number, minImportance?: number, maxContentLength?: number): CallToolResult;
+export declare function recallByTimeframe(timeframe: string, memoryType?: string, project?: string, limit?: number): CallToolResult;
+export declare function searchByTag(tags: string[], matchAll?: boolean, limit?: number): CallToolResult;
+export declare function getMemoryStats(): CallToolResult;
+export declare function deleteMemory(memoryId: number): CallToolResult;