companionbot 0.11.0 → 0.12.0

package/dist/ai/claude.js

@@ -1,48 +1,21 @@
 import Anthropic, { APIError } from "@anthropic-ai/sdk";
 import { tools, executeTool } from "../tools/index.js";
-import { sleep } from "../utils/time.js";
-import { MAX_RETRIES, BASE_RETRY_DELAY_MS, MAX_TOOL_ITERATIONS, TOOL_RESULT_MAX_LENGTH, TOOL_INPUT_SUMMARY_LENGTH, TOOL_OUTPUT_SUMMARY_LENGTH, } from "../utils/constants.js";
-async function withRetry(fn, retries = MAX_RETRIES) {
-    let lastError = null;
-    for (let attempt = 0; attempt < retries; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (error) {
-            // APIError 타입 체크
-            if (error instanceof APIError) {
-                lastError = error;
-                // Rate limit (429)
-                if (error.status === 429) {
-                    const retryAfter = error.headers?.["retry-after"];
-                    const delay = retryAfter
-                        ? parseInt(retryAfter) * 1000
-                        : BASE_RETRY_DELAY_MS * Math.pow(2, attempt);
-                    console.log(`[RateLimit] 429 received, waiting ${delay}ms (attempt ${attempt + 1}/${retries})`);
-                    await sleep(delay);
-                    continue;
-                }
-                // 서버 에러 (500+)
-                if (error.status >= 500) {
-                    const delay = BASE_RETRY_DELAY_MS * Math.pow(2, attempt);
-                    console.log(`[ServerError] ${error.status}, waiting ${delay}ms (attempt ${attempt + 1}/${retries})`);
-                    await sleep(delay);
-                    continue;
-                }
-            }
-            // 일반 Error 처리
-            if (error instanceof Error) {
-                lastError = error;
-            }
-            else {
-                lastError = new Error(String(error));
-            }
-            // 다른 에러는 바로 throw
-            throw error;
-        }
-    }
-    throw lastError;
-}
+import { MAX_TOOL_ITERATIONS, TOOL_INPUT_SUMMARY_LENGTH, TOOL_OUTPUT_SUMMARY_LENGTH, } from "../utils/constants.js";
+import { withRetry, withTimeout, } from "../utils/retry.js";
+import { getToolTimeout } from "../tools/timeout.js";
+import { compressToolResult } from "../tools/compress.js";
+// API 호출 타임아웃 (2분) - Claude의 긴 응답 시간 고려
+const API_TIMEOUT_MS = 120000;
+// 재시도 설정
+const API_RETRY_OPTIONS = {
+    maxRetries: 3,
+    initialDelayMs: 1000,
+    maxDelayMs: 30000,
+    onRetry: (attempt, error, delay) => {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        console.log(`[API Retry] Attempt ${attempt}, waiting ${delay}ms: ${errMsg.slice(0, 100)}`);
+    },
+};
 let anthropic = null;
 function getClient() {
     if (!anthropic) {
@@ -163,31 +136,57 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", thinkingL
         return params;
     };
     let response;
-    response = await withRetry(() => client.messages.create(buildRequestParams()));
+    response = await withRetry(() => withTimeout(() => client.messages.create(buildRequestParams()), API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
     // Tool use 루프 - Claude가 도구 사용을 멈출 때까지 반복
     let iterations = 0;
     while (response.stop_reason === "tool_use" && iterations < MAX_TOOL_ITERATIONS) {
         iterations++;
         const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
-        // 도구 실행 결과 수집
-        const toolResults = [];
-        for (const toolUse of toolUseBlocks) {
-            console.log(`[Tool] ${toolUse.name}:`, JSON.stringify(toolUse.input));
-            const result = await executeTool(toolUse.name, toolUse.input);
-            // 결과가 너무 길면 자르기
-            const truncatedResult = result.length > TOOL_RESULT_MAX_LENGTH
-                ? result.slice(0, TOOL_RESULT_MAX_LENGTH) + "\n... (truncated)"
-                : result;
-            toolResults.push({
-                type: "tool_result",
-                tool_use_id: toolUse.id,
-                content: truncatedResult,
-            });
-            // 도구 사용 기록 (히스토리 참조용)
+        // 도구 병렬 실행 (성능 최적화)
+        console.log(`[Tool] Executing ${toolUseBlocks.length} tool(s) in parallel`);
+        const toolExecutions = await Promise.all(toolUseBlocks.map(async (toolUse) => {
+            const startTime = Date.now();
+            console.log(`[Tool] ${toolUse.name}:`, JSON.stringify(toolUse.input).slice(0, 200));
+            try {
+                // 도구별 타임아웃 적용
+                const timeout = getToolTimeout(toolUse.name);
+                const result = await Promise.race([
+                    executeTool(toolUse.name, toolUse.input),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Tool ${toolUse.name} timed out after ${timeout}ms`)), timeout)),
+                ]);
+                const elapsed = Date.now() - startTime;
+                console.log(`[Tool] ${toolUse.name} completed in ${elapsed}ms`);
+                // 스마트 결과 압축
+                const compressedResult = compressToolResult(toolUse.name, result);
+                return {
+                    toolUse,
+                    result: compressedResult,
+                    success: true,
+                };
+            }
+            catch (error) {
+                const elapsed = Date.now() - startTime;
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.error(`[Tool] ${toolUse.name} failed after ${elapsed}ms:`, errorMsg);
+                return {
+                    toolUse,
+                    result: `Error: ${errorMsg}`,
+                    success: false,
+                };
+            }
+        }));
+        // 결과 수집
+        const toolResults = toolExecutions.map((exec) => ({
+            type: "tool_result",
+            tool_use_id: exec.toolUse.id,
+            content: exec.result,
+        }));
+        // 도구 사용 기록
+        for (const exec of toolExecutions) {
             toolsUsed.push({
-                name: toolUse.name,
-                input: JSON.stringify(toolUse.input).slice(0, TOOL_INPUT_SUMMARY_LENGTH),
-                output: truncatedResult.slice(0, TOOL_OUTPUT_SUMMARY_LENGTH),
+                name: exec.toolUse.name,
+                input: JSON.stringify(exec.toolUse.input).slice(0, TOOL_INPUT_SUMMARY_LENGTH),
+                output: exec.result.slice(0, TOOL_OUTPUT_SUMMARY_LENGTH),
             });
         }
         // 어시스턴트 메시지와 도구 결과 추가
@@ -200,7 +199,7 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", thinkingL
             content: toolResults,
         });
         // 다음 응답 요청 (도구 루프에서도 thinking 유지)
-        response = await withRetry(() => client.messages.create(buildRequestParams()));
+        response = await withRetry(() => withTimeout(() => client.messages.create(buildRequestParams()), API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
     }
     // 반복 횟수 초과 시 경고
     if (iterations >= MAX_TOOL_ITERATIONS) {
@@ -226,8 +225,12 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", thinkingL
  * 스트리밍 중 에러 발생 시 적절한 에러 메시지를 반환하거나 예외를 전파함
  */
 export async function chatSmart(messages, systemPrompt, modelId, thinkingLevel = "medium", onChunk) {
+    // 콜백 정규화
+    const callbacks = typeof onChunk === 'function'
+        ? { onChunk }
+        : (onChunk ?? {});
     // 스트리밍 콜백이 없으면 그냥 일반 chat 사용
-    if (!onChunk) {
+    if (!callbacks.onChunk) {
         const result = await chat(messages, systemPrompt, modelId, thinkingLevel);
         return { text: result.text, usedTools: result.toolsUsed.length > 0, toolsUsed: result.toolsUsed };
     }
@@ -279,7 +282,7 @@ export async function chatSmart(messages, systemPrompt, modelId, thinkingLevel =
             streamingStarted = true;
             accumulated += text;
             try {
-                await onChunk(text, accumulated);
+                await callbacks.onChunk(text, accumulated);
             }
             catch (err) {
                 // editMessageText 실패 등은 무시하고 계속
@@ -293,6 +296,17 @@ export async function chatSmart(messages, systemPrompt, modelId, thinkingLevel =
         // 주의: chat()은 내부에서 withRetry를 사용하므로 여기서 추가 재시도 불필요
         if (stopReason === "tool_use") {
             console.log("[Stream] Tool use detected, falling back to chat()");
+            // 도구 이름 추출하여 콜백 호출
+            const toolUseBlocks = finalMessage.content.filter((block) => block.type === "tool_use");
+            const toolNames = toolUseBlocks.map(t => t.name);
+            if (callbacks.onToolStart && toolNames.length > 0) {
+                try {
+                    await callbacks.onToolStart(toolNames);
+                }
+                catch (err) {
+                    console.warn("[Stream] Tool start callback error (ignored):", err);
+                }
+            }
             const result = await chat(messages, systemPrompt, modelId, thinkingLevel);
             return { text: result.text, usedTools: true, toolsUsed: result.toolsUsed };
         }

package/dist/cli/main.js

@@ -6,6 +6,7 @@ import { createBot } from "../telegram/bot.js";
 import { cleanupHeartbeats } from "../heartbeat/index.js";
 import { cleanupBriefings } from "../briefing/index.js";
 import { cleanupReminders } from "../reminders/index.js";
+import { preloadEmbeddingModel, preloadVectorStore } from "../memory/index.js";
 function createPrompt() {
     return readline.createInterface({
         input: process.stdin,
@@ -233,7 +234,21 @@ async function main() {
     }
     // 4. 환경변수 설정
     process.env.ANTHROPIC_API_KEY = apiKey;
-    // 5. 봇 시작
+    // 5. 🚀 사전 로딩 (첫 응답 속도 개선)
+    console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║                   ⏳ 시스템 사전 로딩...                       ║
+╚═══════════════════════════════════════════════════════════════╝
+`);
+    const preloadStart = Date.now();
+    // 임베딩 모델 + 벡터 저장소 병렬 로딩
+    await Promise.all([
+        preloadEmbeddingModel(),
+        preloadVectorStore(),
+    ]);
+    console.log(`   ✓ 사전 로딩 완료 (${Date.now() - preloadStart}ms)
+`);
+    // 6. 봇 시작
     console.log(`
 ╔═══════════════════════════════════════════════════════════════╗
 ║                      🚀 봇 시작!                              ║

package/dist/config/constants.js

@@ -1,105 +1,179 @@
 /**
  * 전역 상수 설정
- *
  * 하드코딩된 매직 넘버들을 한 곳에서 관리
- * 환경변수로 오버라이드 가능
  */
-// 환경변수에서 숫자 읽기 (기본값 사용)
-function envInt(key, defaultValue) {
-    const val = process.env[key];
-    if (!val)
-        return defaultValue;
-    const parsed = parseInt(val, 10);
-    return isNaN(parsed) ? defaultValue : parsed;
-}
-function envFloat(key, defaultValue) {
-    const val = process.env[key];
-    if (!val)
-        return defaultValue;
-    const parsed = parseFloat(val);
-    return isNaN(parsed) ? defaultValue : parsed;
-}
 // ============================================
 // 세션 관련 설정
 // ============================================
 export const SESSION = {
     /** 최대 동시 세션 수 (LRU 정리) */
-    MAX_SESSIONS: envInt("CB_MAX_SESSIONS", 100),
-    /** 세션 TTL (밀리초) - 기본 24시간 */
-    TTL_MS: envInt("CB_SESSION_TTL_MS", 24 * 60 * 60 * 1000),
+    MAX_SESSIONS: 100,
+    /** 세션 TTL (밀리초) - 24시간 */
+    TTL_MS: 24 * 60 * 60 * 1000,
     /** 메모리에 로드할 최대 히스토리 메시지 수 */
-    MAX_HISTORY_LOAD: envInt("CB_MAX_HISTORY_LOAD", 50),
+    MAX_HISTORY_LOAD: 50,
 };
 // ============================================
 // 토큰/컨텍스트 관련 설정
 // ============================================
 export const TOKENS = {
     /** Claude 최대 컨텍스트 토큰 */
-    MAX_CONTEXT: envInt("CB_MAX_CONTEXT_TOKENS", 100000),
+    MAX_CONTEXT: 100000,
     /** 히스토리 토큰 한도 */
-    MAX_HISTORY: envInt("CB_MAX_HISTORY_TOKENS", 40000),
+    MAX_HISTORY: 40000,
     /** 이 이상이면 자동 요약 시작 */
-    SUMMARY_THRESHOLD: envInt("CB_SUMMARY_THRESHOLD_TOKENS", 25000),
+    SUMMARY_THRESHOLD: 25000,
     /** 핀 맥락 최대 토큰 */
-    MAX_PINNED: envInt("CB_MAX_PINNED_TOKENS", 5000),
+    MAX_PINNED: 5000,
     /** 자동 압축 시작 비율 (0.35 = 35%) */
-    COMPACTION_THRESHOLD: envFloat("CB_COMPACTION_THRESHOLD", 0.35),
+    COMPACTION_THRESHOLD: 0.35,
     /** compact 스킵 기준 토큰 */
-    COMPACT_MIN_TOKENS: envInt("CB_COMPACT_MIN_TOKENS", 5000),
+    COMPACT_MIN_TOKENS: 5000,
 };
 // ============================================
 // 메시지 관련 설정
 // ============================================
 export const MESSAGES = {
     /** 트리밍 시 최소 유지할 최근 메시지 수 */
-    MIN_RECENT: envInt("CB_MIN_RECENT_MESSAGES", 6),
+    MIN_RECENT: 6,
     /** compact 시 유지할 최근 메시지 수 */
-    KEEP_ON_COMPACT: envInt("CB_KEEP_ON_COMPACT", 4),
+    KEEP_ON_COMPACT: 4,
     /** 최대 요약 청크 수 */
-    MAX_SUMMARY_CHUNKS: envInt("CB_MAX_SUMMARY_CHUNKS", 3),
+    MAX_SUMMARY_CHUNKS: 3,
     /** 검색 기본 결과 수 */
-    SEARCH_LIMIT: envInt("CB_SEARCH_LIMIT", 10),
+    SEARCH_LIMIT: 10,
     /** 히스토리 로드 기본 limit */
-    HISTORY_LOAD_LIMIT: envInt("CB_HISTORY_LOAD_LIMIT", 100),
+    HISTORY_LOAD_LIMIT: 100,
 };
 // ============================================
 // 메모리/벡터 저장소 설정
 // ============================================
 export const MEMORY = {
-    /** 벡터 캐시 TTL (밀리초) - 기본 5분 */
-    CACHE_TTL_MS: envInt("CB_MEMORY_CACHE_TTL_MS", 5 * 60 * 1000),
+    /** 벡터 캐시 TTL (밀리초) - 5분 */
+    CACHE_TTL_MS: 5 * 60 * 1000,
     /** 최소 청크 길이 (이하는 무시) */
-    MIN_CHUNK_LENGTH: envInt("CB_MIN_CHUNK_LENGTH", 20),
+    MIN_CHUNK_LENGTH: 20,
     /** 최대 청크 길이 (초과 시 분할) */
-    MAX_CHUNK_LENGTH: envInt("CB_MAX_CHUNK_LENGTH", 500),
+    MAX_CHUNK_LENGTH: 500,
     /** 로드할 최근 메모리 파일 일수 */
-    RECENT_DAYS: envInt("CB_MEMORY_RECENT_DAYS", 30),
+    RECENT_DAYS: 30,
     /** 벡터 검색 기본 topK */
-    SEARCH_TOP_K: envInt("CB_VECTOR_SEARCH_TOP_K", 5),
+    SEARCH_TOP_K: 5,
     /** 벡터 검색 최소 유사도 점수 */
-    MIN_SIMILARITY: envFloat("CB_MIN_SIMILARITY", 0.3),
+    MIN_SIMILARITY: 0.3,
     /** /memory 명령어 표시 일수 */
-    DISPLAY_DAYS: envInt("CB_MEMORY_DISPLAY_DAYS", 7),
+    DISPLAY_DAYS: 7,
     /** /memory 최대 표시 길이 */
-    MAX_DISPLAY_LENGTH: envInt("CB_MEMORY_MAX_DISPLAY_LENGTH", 2000),
+    MAX_DISPLAY_LENGTH: 2000,
 };
 // ============================================
 // 텔레그램/UI 관련 설정
 // ============================================
 export const TELEGRAM = {
-    /** 스트리밍 업데이트 간격 (밀리초) */
-    STREAM_UPDATE_INTERVAL_MS: envInt("CB_STREAM_UPDATE_INTERVAL_MS", 500),
-    /** 최대 이미지 크기 (바이트) - 기본 10MB */
-    MAX_IMAGE_SIZE: envInt("CB_MAX_IMAGE_SIZE", 10 * 1024 * 1024),
+    /** 스트리밍 업데이트 간격 - 적응형 (밀리초) */
+    STREAM_UPDATE_INTERVAL_MS: 500, // 레거시 호환용
+    /** 스트리밍 적응형 간격 설정 */
+    STREAM_INTERVAL: {
+        /** 첫 번째 업데이트 (즉시) */
+        FIRST_MS: 0,
+        /** 초기 빠른 업데이트 (처음 5회) */
+        FAST_MS: 200,
+        /** 이후 일반 간격 */
+        NORMAL_MS: 400,
+        /** 빠른 업데이트 횟수 */
+        FAST_COUNT: 5,
+    },
+    /** 텔레그램 메시지 최대 길이 */
+    MAX_MESSAGE_LENGTH: 4096,
+    /** 최대 이미지 크기 (바이트) - 10MB */
+    MAX_IMAGE_SIZE: 10 * 1024 * 1024,
     /** URL 처리 최대 개수 */
-    MAX_URL_FETCH: envInt("CB_MAX_URL_FETCH", 3),
+    MAX_URL_FETCH: 3,
     /** 캘린더 미리보기 이벤트 수 */
-    CALENDAR_PREVIEW_COUNT: envInt("CB_CALENDAR_PREVIEW_COUNT", 3),
+    CALENDAR_PREVIEW_COUNT: 3,
+    /** 스트리밍 UI 아이콘 */
+    STREAM_ICONS: {
+        THINKING: "💭",
+        TYPING: "▌",
+        TOOL: "🔧",
+        DONE: "",
+    },
+    /** Typing indicator 자동 갱신 간격 (밀리초) - 텔레그램은 5초 후 만료 */
+    TYPING_REFRESH_MS: 4000,
+    /** 도구별 친화적 상태 메시지 */
+    TOOL_STATUS_MESSAGES: {
+        // 검색/정보 조회
+        web_search: { icon: "🔍", text: "웹에서 검색하는 중", estimate: "5-10초" },
+        web_fetch: { icon: "📄", text: "웹페이지 읽는 중", estimate: "3-5초" },
+        get_weather: { icon: "🌤️", text: "날씨 확인 중", estimate: "2-3초" },
+        memory_search: { icon: "🧠", text: "기억 검색 중", estimate: "1-2초" },
+        memory_reindex: { icon: "🧠", text: "기억 재색인 중", estimate: "10-30초" },
+        // 파일 작업
+        read_file: { icon: "📖", text: "파일 읽는 중", estimate: "1초" },
+        write_file: { icon: "✍️", text: "파일 쓰는 중", estimate: "1초" },
+        edit_file: { icon: "✏️", text: "파일 수정 중", estimate: "1초" },
+        list_directory: { icon: "📁", text: "폴더 살펴보는 중", estimate: "1초" },
+        // 명령어 실행
+        run_command: { icon: "⚡", text: "명령어 실행 중", estimate: "변동" },
+        list_sessions: { icon: "📋", text: "세션 목록 확인 중", estimate: "1초" },
+        get_session_log: { icon: "📜", text: "로그 가져오는 중", estimate: "1초" },
+        kill_session: { icon: "🛑", text: "세션 종료 중", estimate: "1초" },
+        // 일정/리마인더
+        get_calendar_events: { icon: "📅", text: "일정 확인 중", estimate: "2-3초" },
+        add_calendar_event: { icon: "📅", text: "일정 추가 중", estimate: "2-3초" },
+        delete_calendar_event: { icon: "📅", text: "일정 삭제 중", estimate: "2초" },
+        set_reminder: { icon: "⏰", text: "알림 설정 중", estimate: "1초" },
+        list_reminders: { icon: "⏰", text: "알림 목록 확인 중", estimate: "1초" },
+        cancel_reminder: { icon: "⏰", text: "알림 취소 중", estimate: "1초" },
+        // 브리핑/하트비트
+        control_briefing: { icon: "☀️", text: "브리핑 설정 중", estimate: "1초" },
+        send_briefing_now: { icon: "☀️", text: "브리핑 준비 중", estimate: "5-10초" },
+        control_heartbeat: { icon: "💓", text: "하트비트 설정 중", estimate: "1초" },
+        run_heartbeat_check: { icon: "💓", text: "체크 실행 중", estimate: "3-5초" },
+        // 서브에이전트
+        spawn_agent: { icon: "🤖", text: "서브에이전트 생성 중", estimate: "2-3초" },
+        list_agents: { icon: "🤖", text: "에이전트 목록 확인 중", estimate: "1초" },
+        cancel_agent: { icon: "🤖", text: "에이전트 취소 중", estimate: "1초" },
+        // Cron
+        add_cron: { icon: "🕐", text: "예약 작업 추가 중", estimate: "1초" },
+        list_crons: { icon: "🕐", text: "예약 작업 확인 중", estimate: "1초" },
+        remove_cron: { icon: "🕐", text: "예약 작업 삭제 중", estimate: "1초" },
+        toggle_cron: { icon: "🕐", text: "예약 작업 설정 중", estimate: "1초" },
+        run_cron: { icon: "🕐", text: "예약 작업 실행 중", estimate: "변동" },
+        // 기타
+        change_model: { icon: "🔄", text: "모델 변경 중", estimate: "1초" },
+        save_memory: { icon: "💾", text: "기억 저장 중", estimate: "1초" },
+        save_persona: { icon: "✨", text: "페르소나 저장 중", estimate: "2초" },
+    },
 };
 // ============================================
 // 보안/토큰 관련 설정
 // ============================================
 export const SECURITY = {
-    /** 리셋 토큰 만료 시간 (밀리초) - 기본 1분 */
-    RESET_TOKEN_TTL_MS: envInt("CB_RESET_TOKEN_TTL_MS", 60000),
+    /** 리셋 토큰 만료 시간 (밀리초) - 1분 */
+    RESET_TOKEN_TTL_MS: 60000,
+};
+// ============================================
+// API/네트워크 설정
+// ============================================
+export const API = {
+    /** Claude API 타임아웃 (밀리초) - 2분 */
+    TIMEOUT_MS: 120000,
+    /** 최대 재시도 횟수 */
+    MAX_RETRIES: 3,
+    /** 초기 재시도 대기 시간 (밀리초) */
+    INITIAL_RETRY_DELAY_MS: 1000,
+    /** 최대 재시도 대기 시간 (밀리초) */
+    MAX_RETRY_DELAY_MS: 30000,
+    /** 재시도 백오프 배수 */
+    BACKOFF_MULTIPLIER: 2,
+};
+// ============================================
+// 메모리 검색 타임아웃 설정
+// ============================================
+export const SEARCH = {
+    /** 전체 검색 타임아웃 (밀리초) */
+    TIMEOUT_MS: 5000,
+    /** 임베딩 생성 타임아웃 (밀리초) */
+    EMBED_TIMEOUT_MS: 3000,
 };

package/dist/config/index.js

@@ -0,0 +1,39 @@
+/**
+ * 설정 파일 로더
+ * config.json에서 사용자 설정을 읽음
+ */
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CONFIG_PATH = resolve(__dirname, "../../config.json");
+const DEFAULT_CONFIG = {
+    thinking: "medium",
+};
+let cachedConfig = null;
+export function loadConfig() {
+    if (cachedConfig)
+        return cachedConfig;
+    if (!existsSync(CONFIG_PATH)) {
+        console.log("[Config] config.json not found, using defaults");
+        cachedConfig = DEFAULT_CONFIG;
+        return cachedConfig;
+    }
+    try {
+        const raw = readFileSync(CONFIG_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        cachedConfig = {
+            thinking: parsed.thinking ?? DEFAULT_CONFIG.thinking,
+        };
+        console.log(`[Config] Loaded: thinking=${cachedConfig.thinking}`);
+        return cachedConfig;
+    }
+    catch (error) {
+        console.error("[Config] Failed to load config.json:", error);
+        cachedConfig = DEFAULT_CONFIG;
+        return cachedConfig;
+    }
+}
+export function getConfig() {
+    return cachedConfig ?? loadConfig();
+}

package/dist/health/index.js

@@ -3,6 +3,7 @@
  * 봇의 상태를 추적하고 모니터링합니다.
  * @module health
  */
+import { getWarmupStatus } from "../warmup.js";
 let startTime = Date.now();
 let lastActivity = Date.now();
 let messageCount = 0;
@@ -36,7 +37,8 @@ export function getHealthStatus() {
         lastActivity,
         messageCount,
         errorCount,
-        isHealthy
+        isHealthy,
+        warmup: getWarmupStatus(),
     };
 }
 /**

package/dist/memory/benchmark.js

@@ -0,0 +1,114 @@
+/**
+ * 메모리 검색 벤치마크
+ *
+ * 사용법: npx tsx src/memory/benchmark.ts
+ */
+import { performance } from "perf_hooks";
+// 현재 구현
+import * as currentVector from "./vectorStore.js";
+import * as currentFts from "./ftsIndex.js";
+import * as currentHybrid from "./hybridSearch.js";
+// 최적화 구현 (주석 해제하여 비교)
+// import * as optimizedVector from "./vectorStore.optimized.js";
+// import * as optimizedFts from "./ftsIndex.optimized.js";
+// import * as optimizedHybrid from "./hybridSearch.optimized.js";
+const TEST_QUERIES = [
+    "오늘 무슨 일이 있었어?",
+    "지난주 회의 내용",
+    "프로젝트 마감일",
+    "API 키 설정",
+    "에러 해결 방법",
+    "CompanionBot feature",
+    "일정 확인",
+    "메모리 검색 최적화",
+    "테스트 코드 작성",
+    "버그 수정",
+];
+async function benchmark(name, fn, iterations = 10) {
+    const times = [];
+    // 워밍업
+    await fn();
+    await fn();
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        await fn();
+        const end = performance.now();
+        times.push(end - start);
+    }
+    times.sort((a, b) => a - b);
+    const avgMs = times.reduce((a, b) => a + b, 0) / times.length;
+    const p95Idx = Math.floor(times.length * 0.95);
+    return {
+        name,
+        avgMs: Math.round(avgMs * 100) / 100,
+        minMs: Math.round(times[0] * 100) / 100,
+        maxMs: Math.round(times[times.length - 1] * 100) / 100,
+        p95Ms: Math.round(times[p95Idx] * 100) / 100,
+        ops: Math.round(1000 / avgMs),
+    };
+}
+function printResult(result) {
+    console.log(`
+${result.name}:
+  Average: ${result.avgMs}ms
+  Min: ${result.minMs}ms
+  Max: ${result.maxMs}ms
+  P95: ${result.p95Ms}ms
+  Ops/sec: ${result.ops}
+`);
+}
+async function main() {
+    console.log("=".repeat(60));
+    console.log("Memory Search Benchmark");
+    console.log("=".repeat(60));
+    console.log(`\nTest queries: ${TEST_QUERIES.length}`);
+    console.log(`Iterations per query: 10\n`);
+    // 1. 벡터 검색 벤치마크
+    console.log("\n--- Vector Search ---");
+    for (const query of TEST_QUERIES.slice(0, 3)) {
+        const result = await benchmark(`Vector search: "${query.slice(0, 20)}..."`, async () => {
+            return currentHybrid.searchVector(query, 5, 0.3);
+        }, 10);
+        printResult(result);
+    }
+    // 2. FTS 검색 벤치마크
+    console.log("\n--- FTS Keyword Search ---");
+    for (const query of TEST_QUERIES.slice(0, 3)) {
+        const result = await benchmark(`FTS search: "${query.slice(0, 20)}..."`, async () => {
+            return currentFts.searchKeyword(query, 10);
+        }, 10);
+        printResult(result);
+    }
+    // 3. 하이브리드 검색 벤치마크
+    console.log("\n--- Hybrid Search ---");
+    for (const query of TEST_QUERIES.slice(0, 3)) {
+        const result = await benchmark(`Hybrid search: "${query.slice(0, 20)}..."`, async () => {
+            return currentHybrid.hybridSearch(query, { topK: 5 });
+        }, 10);
+        printResult(result);
+    }
+    // 4. 청크 로딩 벤치마크
+    console.log("\n--- Chunk Loading ---");
+    // 캐시 무효화 후 로딩 시간
+    currentVector.invalidateCache();
+    const loadResult = await benchmark("Load all chunks (cold)", async () => {
+        currentVector.invalidateCache();
+        return currentVector.loadAllMemoryChunks();
+    }, 5);
+    printResult(loadResult);
+    // 캐시된 로딩 시간
+    const cachedLoadResult = await benchmark("Load all chunks (cached)", async () => {
+        return currentVector.loadAllMemoryChunks();
+    }, 10);
+    printResult(cachedLoadResult);
+    // 5. 통계
+    console.log("\n--- Statistics ---");
+    const chunks = await currentVector.loadAllMemoryChunks();
+    const ftsCount = currentFts.getDocumentCount();
+    console.log(`Total chunks in vector store: ${chunks.length}`);
+    console.log(`Total documents in FTS: ${ftsCount}`);
+    console.log("\n" + "=".repeat(60));
+    console.log("Benchmark complete");
+    console.log("=".repeat(60));
+}
+main().catch(console.error);