claude-session-continuity-mcp 1.1.1 → 1.3.0

package/README.md

@@ -458,4 +458,3 @@ PRs welcome! Please:
 
 - [Model Context Protocol](https://modelcontextprotocol.io/) by Anthropic
 - [Xenova Transformers](https://github.com/xenova/transformers.js) for embeddings
-- Inspired by [mcp-memory-service](https://github.com/doobidoo/mcp-memory-service)

package/dist/db/database.js

@@ -1,10 +1,70 @@
 // SQLite 데이터베이스 초기화 및 관리
 import Database from 'better-sqlite3';
 import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+// ===== 경로 자동 감지 =====
+/**
+ * 워크스페이스 루트 자동 감지
+ * 우선순위:
+ * 1. WORKSPACE_ROOT 환경변수
+ * 2. 현재 디렉토리에서 상위 탐색 (.claude/, apps/, turbo.json)
+ * 3. 현재 작업 디렉토리
+ * 4. 홈 디렉토리 (fallback)
+ */
+function detectWorkspaceRoot() {
+    // 1. 환경변수 우선
+    if (process.env.WORKSPACE_ROOT) {
+        return process.env.WORKSPACE_ROOT;
+    }
+    // 2. 현재 디렉토리에서 상위로 탐색
+    let current = process.cwd();
+    const root = path.parse(current).root;
+    while (current !== root) {
+        // 모노레포 root 감지
+        if (fs.existsSync(path.join(current, 'apps'))) {
+            return current;
+        }
+        // .claude 디렉토리가 있으면 여기가 프로젝트 루트
+        if (fs.existsSync(path.join(current, '.claude'))) {
+            return current;
+        }
+        // turbo.json + package.json = 모노레포
+        if (fs.existsSync(path.join(current, 'turbo.json')) && fs.existsSync(path.join(current, 'package.json'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    // 3. 현재 작업 디렉토리 사용 (단일 프로젝트로 간주)
+    return process.cwd();
+}
+/**
+ * DB 경로 결정
+ * - 워크스페이스 루트의 .claude/sessions.db
+ * - 없으면 생성
+ */
+function getDbPath(workspaceRoot) {
+    const claudeDir = path.join(workspaceRoot, '.claude');
+    // .claude 디렉토리 생성
+    if (!fs.existsSync(claudeDir)) {
+        try {
+            fs.mkdirSync(claudeDir, { recursive: true });
+        }
+        catch {
+            // 권한 없으면 홈 디렉토리에 생성
+            const homeClaudeDir = path.join(os.homedir(), '.claude');
+            if (!fs.existsSync(homeClaudeDir)) {
+                fs.mkdirSync(homeClaudeDir, { recursive: true });
+            }
+            return path.join(homeClaudeDir, 'sessions.db');
+        }
+    }
+    return path.join(claudeDir, 'sessions.db');
+}
 // 기본 경로 설정
-export const WORKSPACE_ROOT = process.env.WORKSPACE_ROOT || '/Users/ibyeongchang/Documents/dev/ai-service-generator';
+export const WORKSPACE_ROOT = detectWorkspaceRoot();
 export const APPS_DIR = path.join(WORKSPACE_ROOT, 'apps');
-const DB_PATH = path.join(WORKSPACE_ROOT, '.claude', 'sessions.db');
+const DB_PATH = getDbPath(WORKSPACE_ROOT);
 // 데이터베이스 인스턴스
 export const db = new Database(DB_PATH);
 // Content Filtering 패턴 캐시

package/dist/hooks/install.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Claude Code Hooks + MCP Server 자동 설치 스크립트
+ *
+ * npm install 시 자동으로:
+ * 1. ~/.claude/settings.local.json에 Hook 등록
+ * 2. ~/.claude.json에 MCP 서버 등록
+ */
+export {};

package/dist/hooks/install.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+/**
+ * Claude Code Hooks + MCP Server 자동 설치 스크립트
+ *
+ * npm install 시 자동으로:
+ * 1. ~/.claude/settings.local.json에 Hook 등록
+ * 2. ~/.claude.json에 MCP 서버 등록
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.local.json');
+const MCP_CONFIG_FILE = path.join(os.homedir(), '.claude.json');
+// 설치된 패키지 경로 찾기
+function getPackagePath() {
+    // 1. 글로벌 설치 확인
+    const globalPath = path.dirname(process.argv[1]);
+    if (fs.existsSync(path.join(globalPath, 'hooks'))) {
+        return globalPath;
+    }
+    // 2. 로컬 node_modules 확인
+    let current = process.cwd();
+    while (current !== path.parse(current).root) {
+        const candidate = path.join(current, 'node_modules', 'claude-session-continuity-mcp', 'dist', 'hooks');
+        if (fs.existsSync(candidate)) {
+            return path.join(current, 'node_modules', 'claude-session-continuity-mcp', 'dist');
+        }
+        current = path.dirname(current);
+    }
+    // 3. 현재 패키지 디렉토리 (ESM 호환)
+    return path.dirname(__dirname);
+}
+function loadSettings() {
+    if (!fs.existsSync(SETTINGS_FILE)) {
+        return {};
+    }
+    try {
+        return JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveSettings(settings) {
+    if (!fs.existsSync(CLAUDE_DIR)) {
+        fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+    }
+    fs.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2));
+}
+function loadMcpConfig() {
+    if (!fs.existsSync(MCP_CONFIG_FILE)) {
+        return {};
+    }
+    try {
+        return JSON.parse(fs.readFileSync(MCP_CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveMcpConfig(config) {
+    fs.writeFileSync(MCP_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function installMcpServer() {
+    console.log('🔧 Registering MCP server...');
+    try {
+        const config = loadMcpConfig();
+        const mcpServers = config.mcpServers || {};
+        // 이미 등록되어 있으면 스킵
+        if (mcpServers['project-manager']) {
+            console.log('   MCP server already registered');
+            return true;
+        }
+        // MCP 서버 등록
+        mcpServers['project-manager'] = {
+            command: 'npx',
+            args: ['claude-session-continuity-mcp']
+        };
+        config.mcpServers = mcpServers;
+        saveMcpConfig(config);
+        console.log('✅ MCP server registered in ~/.claude.json');
+        return true;
+    }
+    catch (error) {
+        console.error('⚠️ Failed to register MCP server:', error);
+        console.log('   You can manually add to ~/.claude.json:');
+        console.log('   {');
+        console.log('     "mcpServers": {');
+        console.log('       "project-manager": {');
+        console.log('         "command": "npx",');
+        console.log('         "args": ["claude-session-continuity-mcp"]');
+        console.log('       }');
+        console.log('     }');
+        console.log('   }');
+        return false;
+    }
+}
+function install() {
+    console.log('');
+    console.log('╔════════════════════════════════════════════════════════════╗');
+    console.log('║   Claude Session Continuity MCP - Installation             ║');
+    console.log('╚════════════════════════════════════════════════════════════╝');
+    console.log('');
+    const packagePath = getPackagePath();
+    const hooksDir = path.join(packagePath, 'hooks');
+    // Hook 스크립트 경로
+    const sessionStartHook = path.join(hooksDir, 'session-start.js');
+    const userPromptHook = path.join(hooksDir, 'user-prompt-submit.js');
+    // ===== 1. Hooks 설치 =====
+    console.log('📌 Step 1: Installing Hooks...');
+    const settings = loadSettings();
+    // 기존 hooks 유지하면서 추가
+    const hooks = settings.hooks || {};
+    // SessionStart Hook
+    hooks.SessionStart = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: `node "${sessionStartHook}"`
+                }
+            ]
+        }
+    ];
+    // UserPromptSubmit Hook
+    hooks.UserPromptSubmit = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: `node "${userPromptHook}"`
+                }
+            ]
+        }
+    ];
+    settings.hooks = hooks;
+    saveSettings(settings);
+    console.log('✅ Hooks installed');
+    console.log(`   SessionStart: ${sessionStartHook}`);
+    console.log(`   UserPromptSubmit: ${userPromptHook}`);
+    console.log('');
+    // ===== 2. MCP 서버 등록 =====
+    console.log('📌 Step 2: Registering MCP Server...');
+    installMcpServer();
+    console.log('');
+    // ===== 완료 메시지 =====
+    console.log('╔════════════════════════════════════════════════════════════╗');
+    console.log('║   ✅ Installation Complete!                                ║');
+    console.log('╠════════════════════════════════════════════════════════════╣');
+    console.log('║                                                            ║');
+    console.log('║   🚀 Restart Claude Code to activate:                      ║');
+    console.log('║      - 24 MCP tools (session_start, memory_store, etc.)    ║');
+    console.log('║      - Auto context injection on session start             ║');
+    console.log('║                                                            ║');
+    console.log('║   📖 Quick Start:                                          ║');
+    console.log('║      1. Start a new Claude Code session                    ║');
+    console.log('║      2. Context will be auto-injected                      ║');
+    console.log('║      3. Use session_end to save context                    ║');
+    console.log('║                                                            ║');
+    console.log('╚════════════════════════════════════════════════════════════╝');
+    console.log('');
+}
+function uninstall() {
+    console.log('🔧 Removing Claude Code Hooks...');
+    const settings = loadSettings();
+    const hooks = settings.hooks || {};
+    // session-continuity 관련 Hook만 제거
+    delete hooks.SessionStart;
+    delete hooks.UserPromptSubmit;
+    if (Object.keys(hooks).length === 0) {
+        delete settings.hooks;
+    }
+    else {
+        settings.hooks = hooks;
+    }
+    saveSettings(settings);
+    console.log('✅ Hooks removed successfully!');
+}
+function status() {
+    console.log('📊 Claude Code Hooks Status\n');
+    if (!fs.existsSync(SETTINGS_FILE)) {
+        console.log('❌ No hooks configured');
+        return;
+    }
+    const settings = loadSettings();
+    const hooks = settings.hooks;
+    if (!hooks) {
+        console.log('❌ No hooks configured');
+        return;
+    }
+    console.log('Configured hooks:');
+    for (const [event, hookList] of Object.entries(hooks)) {
+        console.log(`  ${event}:`);
+        for (const hook of hookList) {
+            for (const h of hook.hooks || []) {
+                console.log(`    → ${h.command}`);
+            }
+        }
+    }
+}
+// CLI
+const args = process.argv.slice(2);
+const command = args[0] || 'install';
+switch (command) {
+    case 'install':
+        install();
+        break;
+    case 'uninstall':
+    case 'remove':
+        uninstall();
+        break;
+    case 'status':
+        status();
+        break;
+    default:
+        console.log('Usage: npx claude-session-continuity-hooks [install|uninstall|status]');
+}

package/dist/hooks/session-start.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * SessionStart Hook - 세션 시작 시 컨텍스트 자동 주입
+ */
+export {};

package/dist/hooks/session-start.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * SessionStart Hook - 세션 시작 시 컨텍스트 자동 주입
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import Database from 'better-sqlite3';
+function detectWorkspaceRoot(cwd) {
+    let current = cwd;
+    const root = path.parse(current).root;
+    while (current !== root) {
+        if (fs.existsSync(path.join(current, 'apps')))
+            return current;
+        if (fs.existsSync(path.join(current, '.claude', 'sessions.db')))
+            return current;
+        if (fs.existsSync(path.join(current, 'package.json'))) {
+            // package.json이 있으면 여기가 프로젝트 루트일 가능성 높음
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return cwd;
+}
+function getProject(cwd, workspaceRoot) {
+    const appsDir = path.join(workspaceRoot, 'apps');
+    // apps/ 하위인지 확인
+    if (cwd.startsWith(appsDir + path.sep)) {
+        const relative = path.relative(appsDir, cwd);
+        return relative.split(path.sep)[0];
+    }
+    // 단일 프로젝트 모드
+    if (!fs.existsSync(appsDir)) {
+        return path.basename(workspaceRoot);
+    }
+    return null;
+}
+function loadContext(dbPath, project) {
+    if (!fs.existsSync(dbPath))
+        return null;
+    try {
+        const db = new Database(dbPath, { readonly: true });
+        const lines = [`# ${project} - Session Resumed\n`];
+        // 기술 스택
+        const fixed = db.prepare('SELECT tech_stack FROM project_context WHERE project = ?').get(project);
+        if (fixed?.tech_stack) {
+            const stack = JSON.parse(fixed.tech_stack);
+            const stackStr = Object.entries(stack).map(([k, v]) => `**${k}**: ${v}`).join(', ');
+            lines.push(`## Tech Stack\n${stackStr}\n`);
+        }
+        // 현재 상태
+        const active = db.prepare('SELECT current_state, blockers FROM active_context WHERE project = ?').get(project);
+        if (active?.current_state) {
+            lines.push(`## Current State\n📍 ${active.current_state}`);
+            if (active.blockers)
+                lines.push(`🚧 **Blocker**: ${active.blockers}`);
+            lines.push('');
+        }
+        // 마지막 세션
+        const last = db.prepare('SELECT last_work, next_tasks, timestamp FROM sessions WHERE project = ? ORDER BY timestamp DESC LIMIT 1').get(project);
+        if (last?.last_work) {
+            lines.push(`## Last Session (${last.timestamp?.slice(0, 10) || 'unknown'})`);
+            lines.push(`**Work**: ${last.last_work}`);
+            if (last.next_tasks) {
+                const next = JSON.parse(last.next_tasks);
+                if (next.length > 0)
+                    lines.push(`**Next**: ${next.slice(0, 3).join(' → ')}`);
+            }
+            lines.push('');
+        }
+        // 미완료 태스크
+        const tasks = db.prepare(`
+      SELECT title, priority, status FROM tasks
+      WHERE project = ? AND status IN ('pending', 'in_progress')
+      ORDER BY priority DESC LIMIT 5
+    `).all(project);
+        if (tasks.length > 0) {
+            lines.push('## 📋 Pending Tasks');
+            for (const t of tasks) {
+                const icon = t.status === 'in_progress' ? '🔄' : '⏳';
+                lines.push(`- ${icon} [P${t.priority}] ${t.title}`);
+            }
+            lines.push('');
+        }
+        // 중요 메모리
+        const memories = db.prepare(`
+      SELECT content, memory_type FROM memories
+      WHERE project = ?
+      ORDER BY importance DESC, created_at DESC LIMIT 5
+    `).all(project);
+        if (memories.length > 0) {
+            const typeIcons = {
+                observation: '👀', decision: '🎯', learning: '📚', error: '⚠️', pattern: '🔄'
+            };
+            lines.push('## 🧠 Key Memories');
+            for (const m of memories) {
+                const icon = typeIcons[m.memory_type] || '💭';
+                const content = m.content.length > 100 ? m.content.slice(0, 100) + '...' : m.content;
+                lines.push(`- ${icon} [${m.memory_type}] ${content}`);
+            }
+            lines.push('');
+        }
+        db.close();
+        lines.push('---');
+        lines.push('_Auto-injected by session-continuity. Use `session_end` when done._');
+        return lines.join('\n');
+    }
+    catch (e) {
+        return null;
+    }
+}
+async function main() {
+    try {
+        // stdin에서 입력 읽기
+        let inputData = '';
+        for await (const chunk of process.stdin) {
+            inputData += chunk;
+        }
+        const input = inputData ? JSON.parse(inputData) : {};
+        const cwd = input.cwd || process.cwd();
+        const workspaceRoot = detectWorkspaceRoot(cwd);
+        const project = getProject(cwd, workspaceRoot);
+        if (!project) {
+            process.exit(0);
+        }
+        const dbPath = path.join(workspaceRoot, '.claude', 'sessions.db');
+        const context = loadContext(dbPath, project);
+        if (context) {
+            console.log(`\n<session-context project="${project}">\n${context}\n</session-context>\n`);
+        }
+        else {
+            console.log(`\n[Session] Project: ${project} (no context yet)\n`);
+        }
+        process.exit(0);
+    }
+    catch (e) {
+        // 에러 시 조용히 종료
+        process.exit(0);
+    }
+}
+main();

package/dist/hooks/user-prompt-submit.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit Hook - 매 프롬프트마다 관련 컨텍스트 자동 주입
+ */
+export {};

package/dist/hooks/user-prompt-submit.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit Hook - 매 프롬프트마다 관련 컨텍스트 자동 주입
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import Database from 'better-sqlite3';
+function detectWorkspaceRoot(cwd) {
+    let current = cwd;
+    const root = path.parse(current).root;
+    while (current !== root) {
+        if (fs.existsSync(path.join(current, 'apps')))
+            return current;
+        if (fs.existsSync(path.join(current, '.claude', 'sessions.db')))
+            return current;
+        if (fs.existsSync(path.join(current, 'package.json'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return cwd;
+}
+function getProject(cwd, workspaceRoot) {
+    const appsDir = path.join(workspaceRoot, 'apps');
+    if (cwd.startsWith(appsDir + path.sep)) {
+        const relative = path.relative(appsDir, cwd);
+        return relative.split(path.sep)[0];
+    }
+    if (!fs.existsSync(appsDir)) {
+        return path.basename(workspaceRoot);
+    }
+    return null;
+}
+function loadContext(dbPath, project) {
+    if (!fs.existsSync(dbPath))
+        return null;
+    try {
+        const db = new Database(dbPath, { readonly: true });
+        const lines = [`# 🚀 ${project} Context\n`];
+        // 기술 스택
+        const fixed = db.prepare('SELECT tech_stack FROM project_context WHERE project = ?').get(project);
+        if (fixed?.tech_stack) {
+            const stack = JSON.parse(fixed.tech_stack);
+            const stackStr = Object.entries(stack).map(([k, v]) => `**${k}**: ${v}`).join(', ');
+            lines.push(`## Tech Stack\n${stackStr}\n`);
+        }
+        // 현재 상태
+        const active = db.prepare('SELECT current_state, blockers, last_verification FROM active_context WHERE project = ?').get(project);
+        if (active?.current_state) {
+            lines.push(`## Current State`);
+            lines.push(`📍 ${active.current_state}`);
+            if (active.blockers)
+                lines.push(`🚧 **Blocker**: ${active.blockers}`);
+            if (active.last_verification) {
+                const emoji = active.last_verification.includes('passed') ? '✅' : '❌';
+                lines.push(`${emoji} Last verify: ${active.last_verification}`);
+            }
+            lines.push('');
+        }
+        // 마지막 세션
+        const last = db.prepare('SELECT last_work, next_tasks, timestamp FROM sessions WHERE project = ? ORDER BY timestamp DESC LIMIT 1').get(project);
+        if (last?.last_work) {
+            lines.push(`## Last Session (${last.timestamp?.slice(0, 10) || 'unknown'})`);
+            lines.push(`**Work**: ${last.last_work}`);
+            if (last.next_tasks) {
+                const next = JSON.parse(last.next_tasks);
+                if (next.length > 0)
+                    lines.push(`**Next**: ${next.slice(0, 3).join(' → ')}`);
+            }
+            lines.push('');
+        }
+        // 미완료 태스크
+        const tasks = db.prepare(`
+      SELECT id, title, priority, status FROM tasks
+      WHERE project = ? AND status IN ('pending', 'in_progress')
+      ORDER BY priority DESC LIMIT 5
+    `).all(project);
+        if (tasks.length > 0) {
+            lines.push('## 📋 Pending Tasks');
+            for (const t of tasks) {
+                const icon = t.status === 'in_progress' ? '🔄' : '⏳';
+                lines.push(`- ${icon} [P${t.priority}] ${t.title} (#${t.id})`);
+            }
+            lines.push('');
+        }
+        // 중요 메모리
+        const memories = db.prepare(`
+      SELECT content, memory_type, importance FROM memories
+      WHERE project = ?
+      ORDER BY importance DESC, created_at DESC LIMIT 5
+    `).all(project);
+        if (memories.length > 0) {
+            const typeIcons = {
+                observation: '👀', decision: '🎯', learning: '📚', error: '⚠️', pattern: '🔄'
+            };
+            lines.push('## 🧠 Key Memories');
+            for (const m of memories) {
+                const icon = typeIcons[m.memory_type] || '💭';
+                const content = m.content.length > 100 ? m.content.slice(0, 100) + '...' : m.content;
+                lines.push(`- ${icon} [${m.memory_type}] ${content}`);
+            }
+            lines.push('');
+        }
+        // 최근 에러 솔루션
+        const solutions = db.prepare(`
+      SELECT error_signature, solution FROM solutions
+      WHERE project = ?
+      ORDER BY created_at DESC LIMIT 3
+    `).all(project);
+        if (solutions.length > 0) {
+            lines.push('## 🔧 Recent Error Solutions');
+            for (const s of solutions) {
+                const sol = s.solution.length > 80 ? s.solution.slice(0, 80) + '...' : s.solution;
+                lines.push(`- **${s.error_signature}**: ${sol}`);
+            }
+            lines.push('');
+        }
+        db.close();
+        lines.push('---');
+        lines.push('_Auto-injected by MCP v5. Use `session_end` when done._');
+        return lines.join('\n');
+    }
+    catch (e) {
+        return null;
+    }
+}
+async function main() {
+    // 환경 변수로 비활성화 가능
+    if (process.env.MCP_HOOKS_DISABLED === 'true') {
+        process.exit(0);
+    }
+    try {
+        // stdin에서 입력 읽기 (타임아웃 방지)
+        let inputData = '';
+        const timeout = setTimeout(() => {
+            // 입력 없으면 그냥 진행
+        }, 100);
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            inputData += chunk;
+        });
+        await new Promise((resolve) => {
+            process.stdin.on('end', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            // 100ms 후 타임아웃
+            setTimeout(resolve, 100);
+        });
+        const cwd = process.cwd();
+        const workspaceRoot = detectWorkspaceRoot(cwd);
+        const project = getProject(cwd, workspaceRoot);
+        if (!project) {
+            process.exit(0);
+        }
+        const dbPath = path.join(workspaceRoot, '.claude', 'sessions.db');
+        const context = loadContext(dbPath, project);
+        if (context) {
+            console.log(`\n<project-context project="${project}">\n${context}\n</project-context>\n`);
+        }
+        process.exit(0);
+    }
+    catch (e) {
+        process.exit(0);
+    }
+}
+main();

package/dist/index.js

@@ -18,6 +18,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import * as fs from 'fs/promises';
+import { mkdirSync, existsSync } from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
 import Database from 'better-sqlite3';
@@ -26,15 +27,63 @@ import { pipeline, env } from '@xenova/transformers';
 // 모델 캐시 설정
 env.cacheDir = path.join(process.env.HOME || '/tmp', '.cache', 'transformers');
 env.allowLocalModels = true;
-// 기본 경로 설정
-const WORKSPACE_ROOT = process.env.WORKSPACE_ROOT || '/Users/ibyeongchang/Documents/dev/ai-service-generator';
+// 기본 경로 설정 (자동 감지)
+function detectWorkspaceRoot() {
+    // 1. 환경변수가 설정되어 있으면 사용
+    if (process.env.WORKSPACE_ROOT) {
+        return process.env.WORKSPACE_ROOT;
+    }
+    // 2. 현재 디렉토리에서 상위로 탐색하며 apps/ 또는 .claude/ 디렉토리 찾기
+    let current = process.cwd();
+    const root = path.parse(current).root;
+    while (current !== root) {
+        // apps/ 디렉토리가 있으면 여기가 workspace root
+        if (existsSync(path.join(current, 'apps'))) {
+            return current;
+        }
+        // .claude/ 디렉토리가 있으면 여기가 workspace root
+        if (existsSync(path.join(current, '.claude'))) {
+            return current;
+        }
+        // package.json + turbo.json이 있으면 모노레포 루트
+        if (existsSync(path.join(current, 'package.json')) && existsSync(path.join(current, 'turbo.json'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    // 3. 못 찾으면 현재 디렉토리 사용 (경고 출력)
+    console.error('Warning: WORKSPACE_ROOT not set and could not auto-detect. Using current directory.');
+    console.error('Set WORKSPACE_ROOT environment variable in your MCP config for best results.');
+    return process.cwd();
+}
+const WORKSPACE_ROOT = detectWorkspaceRoot();
 const APPS_DIR = path.join(WORKSPACE_ROOT, 'apps');
-const DB_PATH = path.join(WORKSPACE_ROOT, '.claude', 'sessions.db');
+const CLAUDE_DIR = path.join(WORKSPACE_ROOT, '.claude');
+const DB_PATH = path.join(CLAUDE_DIR, 'sessions.db');
+// 모노레포 vs 단일 프로젝트 모드 감지
+const IS_MONOREPO = existsSync(APPS_DIR);
+const DEFAULT_PROJECT = IS_MONOREPO ? null : path.basename(WORKSPACE_ROOT);
+// ===== 디렉토리 생성 (동기) =====
+if (!existsSync(CLAUDE_DIR)) {
+    mkdirSync(CLAUDE_DIR, { recursive: true });
+}
 // ===== SQLite 데이터베이스 초기화 =====
 const db = new Database(DB_PATH);
-// v4 스키마 - 메모리 분류 체계 + 지식 그래프 강화
+// v5 스키마 - 세션 + 메모리 분류 체계 + 지식 그래프
 db.exec(`
-  -- 기존 sessions 테이블 사용 (스키마 변경 없음)
+  -- 세션 테이블 (핵심)
+  CREATE TABLE IF NOT EXISTS sessions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    project TEXT NOT NULL,
+    last_work TEXT,
+    current_status TEXT,
+    next_tasks TEXT,
+    modified_files TEXT,
+    issues TEXT,
+    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+  );
+  CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project);
+  CREATE INDEX IF NOT EXISTS idx_sessions_timestamp ON sessions(timestamp DESC);
 
   -- 프로젝트 컨텍스트 (고정)
   CREATE TABLE IF NOT EXISTS project_context (
@@ -249,6 +298,22 @@ function runCommand(cmd, cwd) {
         return { success: false, output: e.stdout || e.stderr || e.message || 'Unknown error' };
     }
 }
+// ===== 프로젝트 경로 헬퍼 (모노레포/단일 프로젝트 호환) =====
+function getProjectPath(project) {
+    // 단일 프로젝트 모드: 프로젝트명이 workspace 이름과 같으면 루트 반환
+    if (!IS_MONOREPO && project === DEFAULT_PROJECT) {
+        return WORKSPACE_ROOT;
+    }
+    // 모노레포 모드: apps/ 하위 경로
+    return path.join(APPS_DIR, project);
+}
+function resolveProject(project) {
+    // 프로젝트명이 없으면 기본 프로젝트 사용 (단일 프로젝트 모드)
+    if (!project && DEFAULT_PROJECT) {
+        return DEFAULT_PROJECT;
+    }
+    return project || 'default';
+}
 // ===== MCP 서버 =====
 const server = new Server({ name: 'project-manager-v5', version: '5.0.0' }, {
     capabilities: {
@@ -619,9 +684,17 @@ async function handleTool(name, args) {
             case 'session_start': {
                 const project = args.project;
                 const compact = args.compact !== false;
-                const projectPath = path.join(APPS_DIR, project);
-                if (!await fileExists(projectPath)) {
-                    return { content: [{ type: 'text', text: `Project not found: ${project}` }] };
+                // 모노레포 모드에서만 프로젝트 디렉토리 체크
+                // 단일 프로젝트 모드나 DB에 이미 데이터가 있으면 스킵
+                if (IS_MONOREPO) {
+                    const projectPath = getProjectPath(project);
+                    if (!await fileExists(projectPath)) {
+                        // DB에 컨텍스트가 있는지 확인 (디렉토리 없어도 컨텍스트는 있을 수 있음)
+                        const hasContext = db.prepare('SELECT 1 FROM project_context WHERE project = ?').get(project);
+                        if (!hasContext) {
+                            return { content: [{ type: 'text', text: `Project not found: ${project}` }] };
+                        }
+                    }
                 }
                 // 고정 컨텍스트
                 const fixedRow = db.prepare('SELECT * FROM project_context WHERE project = ?').get(project);
@@ -770,7 +843,7 @@ async function handleTool(name, args) {
             // ===== 프로젝트 관리 =====
             case 'project_status': {
                 const project = args.project;
-                const projectPath = path.join(APPS_DIR, project);
+                const projectPath = getProjectPath(project);
                 if (!await fileExists(projectPath)) {
                     return { content: [{ type: 'text', text: `Project not found: ${project}` }] };
                 }
@@ -815,7 +888,7 @@ async function handleTool(name, args) {
                 const project = args.project;
                 const techStack = args.techStack;
                 const description = args.description;
-                const projectPath = path.join(APPS_DIR, project);
+                const projectPath = getProjectPath(project);
                 // 기술 스택 자동 감지
                 const detectedStack = await detectTechStack(projectPath);
                 const finalStack = { ...detectedStack, ...techStack };
@@ -836,7 +909,7 @@ async function handleTool(name, args) {
             }
             case 'project_analyze': {
                 const project = args.project;
-                const projectPath = path.join(APPS_DIR, project);
+                const projectPath = getProjectPath(project);
                 if (!await fileExists(projectPath)) {
                     return { content: [{ type: 'text', text: `Project not found: ${project}` }] };
                 }
@@ -867,10 +940,18 @@ async function handleTool(name, args) {
             }
             case 'list_projects': {
                 try {
-                    const entries = await fs.readdir(APPS_DIR, { withFileTypes: true });
-                    const projects = entries
-                        .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-                        .map(e => e.name);
+                    let projects = [];
+                    // 단일 프로젝트 모드
+                    if (!IS_MONOREPO && DEFAULT_PROJECT) {
+                        projects = [DEFAULT_PROJECT];
+                    }
+                    else if (IS_MONOREPO) {
+                        // 모노레포 모드: apps/ 하위 디렉토리
+                        const entries = await fs.readdir(APPS_DIR, { withFileTypes: true });
+                        projects = entries
+                            .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+                            .map(e => e.name);
+                    }
                     // 각 프로젝트 상태 조회
                     const projectsWithStatus = await Promise.all(projects.map(async (p) => {
                         const active = db.prepare('SELECT current_state FROM active_context WHERE project = ?').get(p);
@@ -878,7 +959,8 @@ async function handleTool(name, args) {
                         return {
                             name: p,
                             status: active?.current_state || 'No context',
-                            pendingTasks: taskCount?.count || 0
+                            pendingTasks: taskCount?.count || 0,
+                            mode: IS_MONOREPO ? 'monorepo' : 'single'
                         };
                     }));
                     return { content: [{ type: 'text', text: JSON.stringify(projectsWithStatus, null, 2) }] };
@@ -931,12 +1013,12 @@ async function handleTool(name, args) {
                 const tasks = status === 'all'
                     ? db.prepare(sql).all(project)
                     : db.prepare(sql).all(project, status);
-                return { content: [{ type: 'text', text: JSON.stringify(tasks, null, 2) }] };
+                return { content: [{ type: 'text', text: JSON.stringify({ project, status, count: tasks.length, tasks }, null, 2) }] };
             }
             case 'task_suggest': {
                 const project = args.project;
                 const searchPath = args.path;
-                const projectPath = path.join(APPS_DIR, project, searchPath || '');
+                const projectPath = path.join(getProjectPath(project), searchPath || '');
                 // TODO, FIXME 등 검색
                 try {
                     const result = runCommand(`grep -rn "TODO\\|FIXME\\|HACK\\|XXX" --include="*.ts" --include="*.tsx" --include="*.dart" --include="*.kt" . | head -20`, projectPath);
@@ -984,12 +1066,13 @@ async function handleTool(name, args) {
           INSERT INTO solutions (project, error_signature, error_message, solution, related_files, keywords)
           VALUES (?, ?, ?, ?, ?, ?)
         `).run(project || null, errorSignature, errorMessage || null, solution, relatedFiles ? JSON.stringify(relatedFiles) : null, keywords);
-                // 임베딩 저장 (시맨틱 검색용)
-                const embedding = await generateEmbedding(`${errorSignature} ${errorMessage || ''} ${solution}`);
-                if (embedding) {
-                    const buffer = Buffer.from(new Float32Array(embedding).buffer);
-                    db.prepare('INSERT OR REPLACE INTO embeddings_v3 (type, ref_id, embedding) VALUES (?, ?, ?)').run('solution', result.lastInsertRowid, buffer);
-                }
+                // 임베딩 저장 (시맨틱 검색용) - embeddings_v4 사용
+                generateEmbedding(`${errorSignature} ${errorMessage || ''} ${solution}`).then(embedding => {
+                    if (embedding) {
+                        const buffer = Buffer.from(new Float32Array(embedding).buffer);
+                        db.prepare('INSERT OR REPLACE INTO embeddings_v4 (entity_type, entity_id, embedding) VALUES (?, ?, ?)').run('solution', result.lastInsertRowid, buffer);
+                    }
+                }).catch(() => { });
                 return {
                     content: [{
                             type: 'text',
@@ -1001,55 +1084,30 @@ async function handleTool(name, args) {
                 const query = args.query;
                 const project = args.project;
                 const limit = args.limit || 3;
-                // 키워드 검색 먼저
+                // 키워드 검색 (LIKE 기반, 안정적)
                 const keywordResults = db.prepare(`
           SELECT * FROM solutions
-          WHERE error_signature LIKE ? OR error_message LIKE ? OR keywords LIKE ?
+          WHERE error_signature LIKE ? OR error_message LIKE ? OR solution LIKE ? OR keywords LIKE ?
           ${project ? 'AND project = ?' : ''}
           ORDER BY created_at DESC LIMIT ?
-        `).all(`%${query}%`, `%${query}%`, `%${query}%`, ...(project ? [project, limit] : [limit]));
-                if (keywordResults.length > 0) {
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify(keywordResults.map(r => ({
-                                    id: r.id,
-                                    errorSignature: r.error_signature,
-                                    solution: r.solution,
-                                    project: r.project,
-                                    created: r.created_at
-                                })), null, 2)
-                            }]
-                    };
-                }
-                // 시맨틱 검색 폴백
-                const queryEmb = await generateEmbedding(query);
-                if (!queryEmb) {
-                    return { content: [{ type: 'text', text: 'No solutions found' }] };
-                }
-                const allSolutions = db.prepare(`
-          SELECT s.*, e.embedding FROM solutions s
-          LEFT JOIN embeddings_v3 e ON e.type = 'solution' AND e.ref_id = s.id
-          ${project ? 'WHERE s.project = ?' : ''}
-          LIMIT 50
-        `).all(project ? [project] : []);
-                const scored = allSolutions.map(s => {
-                    if (!s.embedding)
-                        return { ...s, similarity: 0 };
-                    const emb = Array.from(new Float32Array(s.embedding.buffer));
-                    return { ...s, similarity: cosineSimilarity(queryEmb, emb) };
-                });
-                scored.sort((a, b) => b.similarity - a.similarity);
-                const topResults = scored.slice(0, limit);
+        `).all(`%${query}%`, `%${query}%`, `%${query}%`, `%${query}%`, ...(project ? [project, limit] : [limit]));
+                const results = keywordResults.map(r => ({
+                    id: r.id,
+                    errorSignature: r.error_signature,
+                    errorMessage: r.error_message,
+                    solution: r.solution,
+                    project: r.project,
+                    relatedFiles: r.related_files,
+                    created: r.created_at
+                }));
                 return {
                     content: [{
                             type: 'text',
-                            text: JSON.stringify(topResults.map(r => ({
-                                id: r.id,
-                                errorSignature: r.error_signature,
-                                solution: r.solution,
-                                similarity: Math.round(r.similarity * 100) + '%'
-                            })), null, 2)
+                            text: JSON.stringify({
+                                query,
+                                found: results.length,
+                                results
+                            }, null, 2)
                         }]
                 };
             }
@@ -1081,7 +1139,7 @@ async function handleTool(name, args) {
             // ===== 검증/품질 =====
             case 'verify_build': {
                 const project = args.project;
-                const projectPath = path.join(APPS_DIR, project);
+                const projectPath = getProjectPath(project);
                 const platform = await detectPlatform(projectPath);
                 let cmd;
                 switch (platform) {
@@ -1113,7 +1171,7 @@ async function handleTool(name, args) {
             case 'verify_test': {
                 const project = args.project;
                 const testPath = args.testPath;
-                const projectPath = path.join(APPS_DIR, project);
+                const projectPath = getProjectPath(project);
                 const platform = await detectPlatform(projectPath);
                 let cmd;
                 switch (platform) {
@@ -1137,7 +1195,7 @@ async function handleTool(name, args) {
             case 'verify_all': {
                 const project = args.project;
                 const stopOnFail = args.stopOnFail === true;
-                const projectPath = path.join(APPS_DIR, project);
+                const projectPath = getProjectPath(project);
                 const platform = await detectPlatform(projectPath);
                 const results = [];
                 // Build
@@ -1187,6 +1245,13 @@ async function handleTool(name, args) {
                 const tags = args.tags;
                 const importance = args.importance || 5;
                 const relatedTo = args.relatedTo;
+                // 필수 파라미터 검증
+                if (!content || content.trim().length === 0) {
+                    return { content: [{ type: 'text', text: 'Error: content is required and cannot be empty' }] };
+                }
+                if (!memoryType) {
+                    return { content: [{ type: 'text', text: 'Error: type is required' }] };
+                }
                 // 메모리 저장
                 const result = db.prepare(`
           INSERT INTO memories (content, memory_type, tags, project, importance, metadata)
@@ -1250,43 +1315,35 @@ async function handleTool(name, args) {
                     }
                 }
                 else {
-                    // FTS5 키워드 검색
-                    const ftsQuery = query.split(/\s+/).filter(w => w.length > 1).map(w => `"${w}"`).join(' OR ');
+                    // LIKE 기반 키워드 검색 (FTS5보다 안정적)
+                    // 검색어를 단어로 분리하여 OR 조건으로 검색
+                    const words = query.split(/\s+/).filter(w => w.length > 0);
+                    const likeConditions = words.map(() => '(content LIKE ? OR tags LIKE ?)').join(' OR ');
+                    const likeParams = [];
+                    words.forEach(w => {
+                        likeParams.push(`%${w}%`, `%${w}%`);
+                    });
                     let sql = `
-            SELECT m.* FROM memories m
-            JOIN memories_fts fts ON m.id = fts.rowid
-            WHERE memories_fts MATCH ?
-            AND m.importance >= ?
+            SELECT * FROM memories
+            WHERE (${likeConditions || 'content LIKE ?'})
+            AND importance >= ?
           `;
-                    const params = [ftsQuery || `"${query}"`, minImportance];
+                    const params = [...(likeConditions ? likeParams : [`%${query}%`]), minImportance];
                     if (memoryType && memoryType !== 'all') {
-                        sql += ` AND m.memory_type = ?`;
+                        sql += ` AND memory_type = ?`;
                         params.push(memoryType);
                     }
                     if (project) {
-                        sql += ` AND m.project = ?`;
+                        sql += ` AND project = ?`;
                         params.push(project);
                     }
                     if (tags && tags.length > 0) {
-                        sql += ` AND (${tags.map(() => 'm.tags LIKE ?').join(' OR ')})`;
+                        sql += ` AND (${tags.map(() => 'tags LIKE ?').join(' OR ')})`;
                         params.push(...tags.map(t => `%"${t}"%`));
                     }
-                    sql += ` ORDER BY m.importance DESC, m.accessed_at DESC LIMIT ?`;
+                    sql += ` ORDER BY importance DESC, accessed_at DESC LIMIT ?`;
                     params.push(limit);
-                    try {
-                        results = db.prepare(sql).all(...params);
-                    }
-                    catch {
-                        // FTS 실패 시 LIKE 폴백
-                        results = db.prepare(`
-              SELECT * FROM memories
-              WHERE (content LIKE ? OR tags LIKE ?)
-              AND importance >= ?
-              ${memoryType && memoryType !== 'all' ? 'AND memory_type = ?' : ''}
-              ${project ? 'AND project = ?' : ''}
-              ORDER BY importance DESC LIMIT ?
-            `).all(`%${query}%`, `%${query}%`, minImportance, ...(memoryType && memoryType !== 'all' ? [memoryType] : []), ...(project ? [project] : []), limit);
-                    }
+                    results = db.prepare(sql).all(...params);
                 }
                 // 접근 기록 업데이트
                 const ids = results.map(r => r.id);
@@ -1623,7 +1680,7 @@ const prompts = [
 ];
 // ===== Prompt 내용 생성 함수 =====
 async function generateProjectContext(project) {
-    const projectPath = path.join(APPS_DIR, project);
+    const projectPath = getProjectPath(project);
     // 프로젝트 존재 확인
     if (!await fileExists(projectPath)) {
         return `⚠️ 프로젝트를 찾을 수 없습니다: ${project}\n\napps/ 디렉토리에서 사용 가능한 프로젝트를 확인하세요.`;

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "claude-session-continuity-mcp",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "Session Continuity for Claude Code - Never re-explain your project again",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "claude-session-continuity-mcp": "./dist/index.js"
+    "claude-session-continuity-mcp": "./dist/index.js",
+    "claude-session-hooks": "./dist/hooks/install.js"
   },
   "scripts": {
     "build": "tsc",
@@ -17,6 +18,7 @@
     "test:coverage": "vitest run --coverage",
     "dashboard": "node dist/dashboard.js",
     "dashboard:v2": "node dist/dashboard-v2.js",
+    "postinstall": "node dist/hooks/install.js install 2>/dev/null || true",
     "prepublishOnly": "npm run build && npm test"
   },
   "keywords": [
@@ -43,6 +45,7 @@
   "homepage": "https://github.com/leesgit/claude-session-continuity-mcp#readme",
   "files": [
     "dist",
+    "dist/hooks",
     "README.md",
     "LICENSE"
   ],