companionbot 0.10.1 → 0.11.1

package/dist/ai/claude.js

@@ -1,7 +1,7 @@
 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 } from "../utils/constants.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++) {
@@ -50,29 +50,70 @@ function getClient() {
     }
     return anthropic;
 }
-// 모델별 max_tokens 및 thinking budget 설정
-// 참고: Claude API에서 thinking + output이 모델 한도 초과하면 안 됨
+// Thinking 레벨별 설정 (비율 및 최대값)
+export const THINKING_CONFIGS = {
+    off: { ratio: 0, maxBudget: 0 },
+    low: { ratio: 0.3, maxBudget: 5000 },
+    medium: { ratio: 0.5, maxBudget: 10000 },
+    high: { ratio: 0.7, maxBudget: 20000 },
+};
+// 모델별 설정
 export const MODELS = {
     haiku: {
         id: "claude-haiku-3-5-20241022",
         name: "Claude Haiku 3.5",
-        maxTokens: 4096, // 빠른 응답
-        thinkingBudget: 0, // Haiku는 thinking 미지원
+        contextWindow: 200000,
+        supportsThinking: false, // Haiku는 thinking 미지원
     },
     sonnet: {
         id: "claude-sonnet-4-20250514",
         name: "Claude Sonnet 4",
-        maxTokens: 16000, // 일반 작업 (must be > thinkingBudget)
-        thinkingBudget: 10000, // 적당한 thinking
+        contextWindow: 200000,
+        supportsThinking: true,
     },
     opus: {
         id: "claude-opus-4-20250514",
         name: "Claude Opus 4",
-        maxTokens: 64000, // 복잡한 작업 (must be > thinkingBudget)
-        thinkingBudget: 32000, // 깊은 thinking
+        contextWindow: 200000,
+        supportsThinking: true,
     },
 };
-export async function chat(messages, systemPrompt, modelId = "sonnet") {
+// 동적 토큰 계산을 위한 설정
+const MIN_OUTPUT_TOKENS = 4096; // 최소 출력 토큰
+const OUTPUT_BUFFER_RATIO = 0.3; // 컨텍스트의 30%를 출력용으로 예약
+/**
+ * 동적으로 max_tokens와 thinking budget 계산
+ *
+ * @param modelId 모델 ID
+ * @param thinkingLevel thinking 레벨
+ * @param inputTokens 현재 입력 토큰 수 (시스템 프롬프트 + 히스토리)
+ * @returns { maxTokens, thinkingBudget }
+ */
+export function calculateTokenBudgets(modelId, thinkingLevel, inputTokens) {
+    const model = MODELS[modelId];
+    const thinkingConfig = THINKING_CONFIGS[thinkingLevel];
+    // Thinking 미지원 모델이거나 off인 경우
+    if (!model.supportsThinking || thinkingLevel === "off") {
+        // 간단히 고정 max_tokens 사용
+        return { maxTokens: 8192, thinkingBudget: 0 };
+    }
+    // 사용 가능한 출력 토큰 계산
+    // 컨텍스트 윈도우 - 입력 토큰 = 출력 가능 토큰
+    const availableOutputTokens = model.contextWindow - inputTokens;
+    // 최소 출력 토큰 보장
+    const maxTokens = Math.max(MIN_OUTPUT_TOKENS, Math.floor(availableOutputTokens * OUTPUT_BUFFER_RATIO));
+    // thinking budget 계산: min(레벨별 최대값, max_tokens * 비율)
+    // API 조건: max_tokens > budget_tokens 이므로 max_tokens - 1024 로 상한 설정
+    const calculatedBudget = Math.floor(maxTokens * thinkingConfig.ratio);
+    const thinkingBudget = Math.min(thinkingConfig.maxBudget, calculatedBudget, maxTokens - 1024 // max_tokens > budget_tokens 조건 충족
+    );
+    // budget이 1024 미만이면 thinking 비활성화 (의미 없음)
+    if (thinkingBudget < 1024) {
+        return { maxTokens, thinkingBudget: 0 };
+    }
+    return { maxTokens, thinkingBudget };
+}
+export async function chat(messages, systemPrompt, modelId = "sonnet", thinkingLevel = "medium") {
     const client = getClient();
     const modelConfig = MODELS[modelId];
     const toolsUsed = [];
@@ -81,11 +122,31 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
         role: m.role,
         content: m.content,
     }));
+    // 입력 토큰 추정 (대략적)
+    const estimateInputTokens = () => {
+        let total = 0;
+        // 시스템 프롬프트
+        if (systemPrompt) {
+            total += Math.ceil(systemPrompt.length / 3); // 대략 3자당 1토큰
+        }
+        // 메시지들
+        for (const msg of apiMessages) {
+            const content = typeof msg.content === "string"
+                ? msg.content
+                : JSON.stringify(msg.content);
+            total += Math.ceil(content.length / 3);
+        }
+        return total;
+    };
+    // 동적 토큰 budget 계산
+    const inputTokens = estimateInputTokens();
+    const { maxTokens, thinkingBudget } = calculateTokenBudgets(modelId, thinkingLevel, inputTokens);
+    console.log(`[Chat] model=${modelId}, thinking=${thinkingLevel}, input~${inputTokens}, maxTokens=${maxTokens}, budget=${thinkingBudget}`);
     // API 요청 파라미터 빌드 (도구 루프에서도 동일하게 사용)
     const buildRequestParams = () => {
         const params = {
             model: modelConfig.id,
-            max_tokens: modelConfig.maxTokens,
+            max_tokens: maxTokens,
             messages: apiMessages,
             tools: tools,
         };
@@ -93,18 +154,17 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
             params.system = systemPrompt;
         }
         // thinking 활성화 (budget > 0인 경우)
-        if (modelConfig.thinkingBudget > 0) {
+        if (thinkingBudget > 0) {
             params.thinking = {
                 type: "enabled",
-                budget_tokens: modelConfig.thinkingBudget,
+                budget_tokens: thinkingBudget,
             };
         }
         return params;
     };
     let response;
     response = await withRetry(() => client.messages.create(buildRequestParams()));
-    // Tool use 루프 - Claude가 도구 사용을 멈출 때까지 반복 (최대 10회)
-    const MAX_TOOL_ITERATIONS = 10;
+    // Tool use 루프 - Claude가 도구 사용을 멈출 때까지 반복
     let iterations = 0;
     while (response.stop_reason === "tool_use" && iterations < MAX_TOOL_ITERATIONS) {
         iterations++;
@@ -115,8 +175,8 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
             console.log(`[Tool] ${toolUse.name}:`, JSON.stringify(toolUse.input));
             const result = await executeTool(toolUse.name, toolUse.input);
             // 결과가 너무 길면 자르기
-            const truncatedResult = result.length > 10000
-                ? result.slice(0, 10000) + "\n... (truncated)"
+            const truncatedResult = result.length > TOOL_RESULT_MAX_LENGTH
+                ? result.slice(0, TOOL_RESULT_MAX_LENGTH) + "\n... (truncated)"
                 : result;
             toolResults.push({
                 type: "tool_result",
@@ -126,8 +186,8 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
             // 도구 사용 기록 (히스토리 참조용)
             toolsUsed.push({
                 name: toolUse.name,
-                input: JSON.stringify(toolUse.input).slice(0, 200),
-                output: truncatedResult.slice(0, 500),
+                input: JSON.stringify(toolUse.input).slice(0, TOOL_INPUT_SUMMARY_LENGTH),
+                output: truncatedResult.slice(0, TOOL_OUTPUT_SUMMARY_LENGTH),
             });
         }
         // 어시스턴트 메시지와 도구 결과 추가
@@ -165,10 +225,10 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
  * 주의: 스트리밍은 재시도하지 않음 (이미 전송된 청크를 되돌릴 수 없음)
  * 스트리밍 중 에러 발생 시 적절한 에러 메시지를 반환하거나 예외를 전파함
  */
-export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
+export async function chatSmart(messages, systemPrompt, modelId, thinkingLevel = "medium", onChunk) {
     // 스트리밍 콜백이 없으면 그냥 일반 chat 사용
     if (!onChunk) {
-        const result = await chat(messages, systemPrompt, modelId);
+        const result = await chat(messages, systemPrompt, modelId, thinkingLevel);
         return { text: result.text, usedTools: result.toolsUsed.length > 0, toolsUsed: result.toolsUsed };
     }
     const client = getClient();
@@ -178,10 +238,24 @@ export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
         role: m.role,
         content: m.content,
     }));
+    // 입력 토큰 추정
+    let inputTokens = 0;
+    if (systemPrompt) {
+        inputTokens += Math.ceil(systemPrompt.length / 3);
+    }
+    for (const msg of apiMessages) {
+        const content = typeof msg.content === "string"
+            ? msg.content
+            : JSON.stringify(msg.content);
+        inputTokens += Math.ceil(content.length / 3);
+    }
+    // 동적 토큰 budget 계산
+    const { maxTokens, thinkingBudget } = calculateTokenBudgets(modelId, thinkingLevel, inputTokens);
+    console.log(`[ChatSmart] model=${modelId}, thinking=${thinkingLevel}, input~${inputTokens}, maxTokens=${maxTokens}, budget=${thinkingBudget}`);
     // 스트리밍 요청 파라미터
     const params = {
         model: modelConfig.id,
-        max_tokens: modelConfig.maxTokens,
+        max_tokens: maxTokens,
         messages: apiMessages,
         tools: tools,
         stream: true,
@@ -189,8 +263,13 @@ export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
     if (systemPrompt) {
         params.system = systemPrompt;
     }
-    // Thinking은 스트리밍에서 복잡해지므로 일단 비활성화
-    // (도구 호출 폴백 시 chat()에서 thinking 사용됨)
+    // Thinking 활성화 (스트리밍에서도 지원)
+    if (thinkingBudget > 0) {
+        params.thinking = {
+            type: "enabled",
+            budget_tokens: thinkingBudget,
+        };
+    }
     let accumulated = "";
     let streamingStarted = false;
     try {
@@ -214,7 +293,7 @@ export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
         // 주의: chat()은 내부에서 withRetry를 사용하므로 여기서 추가 재시도 불필요
         if (stopReason === "tool_use") {
             console.log("[Stream] Tool use detected, falling back to chat()");
-            const result = await chat(messages, systemPrompt, modelId);
+            const result = await chat(messages, systemPrompt, modelId, thinkingLevel);
             return { text: result.text, usedTools: true, toolsUsed: result.toolsUsed };
         }
         // 성공적으로 스트리밍 완료
@@ -228,7 +307,7 @@ export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
                 console.log(`[Stream] Pre-stream error (${error.status}), retrying with withRetry...`);
                 return await withRetry(async () => {
                     // 재시도 시 일반 chat 사용 (스트리밍 대신)
-                    const result = await chat(messages, systemPrompt, modelId);
+                    const result = await chat(messages, systemPrompt, modelId, thinkingLevel);
                     return { text: result.text, usedTools: false, toolsUsed: result.toolsUsed };
                 });
             }

package/dist/config/constants.js

@@ -0,0 +1,88 @@
+/**
+ * 전역 상수 설정
+ * 하드코딩된 매직 넘버들을 한 곳에서 관리
+ */
+// ============================================
+// 세션 관련 설정
+// ============================================
+export const SESSION = {
+    /** 최대 동시 세션 수 (LRU 정리) */
+    MAX_SESSIONS: 100,
+    /** 세션 TTL (밀리초) - 24시간 */
+    TTL_MS: 24 * 60 * 60 * 1000,
+    /** 메모리에 로드할 최대 히스토리 메시지 수 */
+    MAX_HISTORY_LOAD: 50,
+};
+// ============================================
+// 토큰/컨텍스트 관련 설정
+// ============================================
+export const TOKENS = {
+    /** Claude 최대 컨텍스트 토큰 */
+    MAX_CONTEXT: 100000,
+    /** 히스토리 토큰 한도 */
+    MAX_HISTORY: 40000,
+    /** 이 이상이면 자동 요약 시작 */
+    SUMMARY_THRESHOLD: 25000,
+    /** 핀 맥락 최대 토큰 */
+    MAX_PINNED: 5000,
+    /** 자동 압축 시작 비율 (0.35 = 35%) */
+    COMPACTION_THRESHOLD: 0.35,
+    /** compact 스킵 기준 토큰 */
+    COMPACT_MIN_TOKENS: 5000,
+};
+// ============================================
+// 메시지 관련 설정
+// ============================================
+export const MESSAGES = {
+    /** 트리밍 시 최소 유지할 최근 메시지 수 */
+    MIN_RECENT: 6,
+    /** compact 시 유지할 최근 메시지 수 */
+    KEEP_ON_COMPACT: 4,
+    /** 최대 요약 청크 수 */
+    MAX_SUMMARY_CHUNKS: 3,
+    /** 검색 기본 결과 수 */
+    SEARCH_LIMIT: 10,
+    /** 히스토리 로드 기본 limit */
+    HISTORY_LOAD_LIMIT: 100,
+};
+// ============================================
+// 메모리/벡터 저장소 설정
+// ============================================
+export const MEMORY = {
+    /** 벡터 캐시 TTL (밀리초) - 5분 */
+    CACHE_TTL_MS: 5 * 60 * 1000,
+    /** 최소 청크 길이 (이하는 무시) */
+    MIN_CHUNK_LENGTH: 20,
+    /** 최대 청크 길이 (초과 시 분할) */
+    MAX_CHUNK_LENGTH: 500,
+    /** 로드할 최근 메모리 파일 일수 */
+    RECENT_DAYS: 30,
+    /** 벡터 검색 기본 topK */
+    SEARCH_TOP_K: 5,
+    /** 벡터 검색 최소 유사도 점수 */
+    MIN_SIMILARITY: 0.3,
+    /** /memory 명령어 표시 일수 */
+    DISPLAY_DAYS: 7,
+    /** /memory 최대 표시 길이 */
+    MAX_DISPLAY_LENGTH: 2000,
+};
+// ============================================
+// 텔레그램/UI 관련 설정
+// ============================================
+export const TELEGRAM = {
+    /** 스트리밍 업데이트 간격 (밀리초) */
+    STREAM_UPDATE_INTERVAL_MS: 500,
+    /** 최대 이미지 크기 (바이트) - 10MB */
+    MAX_IMAGE_SIZE: 10 * 1024 * 1024,
+    /** URL 처리 최대 개수 */
+    MAX_URL_FETCH: 3,
+    /** 캘린더 미리보기 이벤트 수 */
+    CALENDAR_PREVIEW_COUNT: 3,
+};
+// ============================================
+// 보안/토큰 관련 설정
+// ============================================
+export const SECURITY = {
+    /** 리셋 토큰 만료 시간 (밀리초) - 1분 */
+    RESET_TOKEN_TTL_MS: 60000,
+};

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/memory/indexer.js

@@ -7,6 +7,7 @@ import * as path from "path";
 import { invalidateCache, loadAllMemoryChunks } from "./vectorStore.js";
 import { indexTextBatch, clearIndex as clearFtsIndex, getDocumentCount } from "./ftsIndex.js";
 import { getMemoryDirPath, getWorkspaceFilePath } from "../workspace/paths.js";
+import { MEMORY } from "../config/constants.js";
 /**
  * 텍스트를 청크로 분할합니다.
  */
@@ -17,14 +18,14 @@ function splitIntoChunks(text, source) {
     const sections = text.split(/(?=^## )/m);
     for (const section of sections) {
         const trimmed = section.trim();
-        if (!trimmed || trimmed.length < 20)
+        if (!trimmed || trimmed.length < MEMORY.MIN_CHUNK_LENGTH)
             continue;
         // 청크가 너무 길면 추가로 분할
-        if (trimmed.length > 500) {
+        if (trimmed.length > MEMORY.MAX_CHUNK_LENGTH) {
             const lines = trimmed.split("\n");
             let currentChunk = "";
             for (const line of lines) {
-                if (currentChunk.length + line.length > 500) {
+                if (currentChunk.length + line.length > MEMORY.MAX_CHUNK_LENGTH) {
                     if (currentChunk.trim()) {
                         chunks.push({
                             id: `${source}:${chunkIndex++}`,
@@ -88,7 +89,7 @@ export async function indexMainMemory() {
 /**
  * 일일 메모리 파일들 인덱싱
  */
-export async function indexDailyMemories(days = 30) {
+export async function indexDailyMemories(days = MEMORY.RECENT_DAYS) {
     const memoryDir = getMemoryDirPath();
     let totalChunks = 0;
     try {

package/dist/memory/vectorStore.js

@@ -7,10 +7,10 @@ import * as fs from "fs/promises";
 import * as path from "path";
 import { getMemoryDirPath, getWorkspaceFilePath } from "../workspace/paths.js";
 import { embed, embedBatch, cosineSimilarity } from "./embeddings.js";
+import { MEMORY } from "../config/constants.js";
 // 캐시된 청크들 (임베딩 포함)
 let cachedChunks = [];
 let cacheTimestamp = 0;
-const CACHE_TTL_MS = 5 * 60 * 1000; // 5분
 // 임베딩 영속 캐시 (hash → embedding)
 let embeddingCache = new Map();
 let embeddingCacheLoaded = false;
@@ -75,14 +75,14 @@ function splitIntoChunks(text, source) {
     const sections = text.split(/(?=^## )/m);
     for (const section of sections) {
         const trimmed = section.trim();
-        if (!trimmed || trimmed.length < 20)
+        if (!trimmed || trimmed.length < MEMORY.MIN_CHUNK_LENGTH)
             continue;
         // 청크가 너무 길면 추가로 분할
-        if (trimmed.length > 500) {
+        if (trimmed.length > MEMORY.MAX_CHUNK_LENGTH) {
             const lines = trimmed.split("\n");
             let currentChunk = "";
             for (const line of lines) {
-                if (currentChunk.length + line.length > 500) {
+                if (currentChunk.length + line.length > MEMORY.MAX_CHUNK_LENGTH) {
                     if (currentChunk.trim()) {
                         chunks.push({
                             text: currentChunk.trim(),
@@ -121,11 +121,11 @@ async function doLoadAllMemoryChunks() {
     // 임베딩 캐시 로드
     await loadEmbeddingCache();
     const chunks = [];
-    // 1. 일별 메모리 파일 (최근 30일)
+    // 1. 일별 메모리 파일
     const memoryDir = getMemoryDirPath();
     try {
         const files = await fs.readdir(memoryDir);
-        const mdFiles = files.filter(f => f.endsWith(".md") && !f.startsWith(".")).sort().reverse().slice(0, 30);
+        const mdFiles = files.filter(f => f.endsWith(".md") && !f.startsWith(".")).sort().reverse().slice(0, MEMORY.RECENT_DAYS);
         for (const file of mdFiles) {
             try {
                 const content = await fs.readFile(path.join(memoryDir, file), "utf-8");
@@ -168,7 +168,7 @@ async function doLoadAllMemoryChunks() {
 export async function loadAllMemoryChunks() {
     const now = Date.now();
     // 캐시가 유효하면 반환
-    if (cachedChunks.length > 0 && now - cacheTimestamp < CACHE_TTL_MS) {
+    if (cachedChunks.length > 0 && now - cacheTimestamp < MEMORY.CACHE_TTL_MS) {
         return cachedChunks;
     }
     // 이미 로딩 중이면 해당 Promise 반환 (중복 로드 방지)
@@ -182,7 +182,7 @@ export async function loadAllMemoryChunks() {
         // 캐시 업데이트 (임베딩은 아직 없음)
         // 빈 결과도 캐시하되 TTL을 짧게 (1분)
         cachedChunks = chunks;
-        cacheTimestamp = chunks.length > 0 ? Date.now() : Date.now() - CACHE_TTL_MS + 60000;
+        cacheTimestamp = chunks.length > 0 ? Date.now() : Date.now() - MEMORY.CACHE_TTL_MS + 60000;
         return chunks;
     }
     catch (error) {
@@ -200,7 +200,7 @@ export async function loadAllMemoryChunks() {
  * @param topK 반환할 최대 결과 수
  * @param minScore 최소 유사도 점수 (0-1)
  */
-export async function search(queryEmbedding, topK = 5, minScore = 0.3) {
+export async function search(queryEmbedding, topK = MEMORY.SEARCH_TOP_K, minScore = MEMORY.MIN_SIMILARITY) {
     const chunks = await loadAllMemoryChunks();
     if (chunks.length === 0) {
         return [];

package/dist/session/persistence.js

@@ -9,6 +9,7 @@ import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 import * as readline from "readline";
+import { MESSAGES } from "../config/constants.js";
 // 저장 경로
 const SESSIONS_DIR = path.join(os.homedir(), ".companionbot", "sessions");
 /**
@@ -52,7 +53,7 @@ export function appendMessage(chatId, role, content) {
  * @param limit 최근 N개만 로드 (메모리 절약, 0 = 전부)
  * @returns 로드된 메시지 배열
  */
-export async function loadHistory(chatId, limit = 100) {
+export async function loadHistory(chatId, limit = MESSAGES.HISTORY_LOAD_LIMIT) {
     const filePath = getSessionFilePath(chatId);
     if (!fs.existsSync(filePath)) {
         return [];
@@ -89,7 +90,7 @@ export async function loadHistory(chatId, limit = 100) {
 /**
  * 동기 버전 히스토리 로드 (초기화 시 사용)
  */
-export function loadHistorySync(chatId, limit = 100) {
+export function loadHistorySync(chatId, limit = MESSAGES.HISTORY_LOAD_LIMIT) {
     const filePath = getSessionFilePath(chatId);
     if (!fs.existsSync(filePath)) {
         return [];
@@ -184,7 +185,7 @@ export function listSessionFiles() {
  * @param limit 최대 결과 수
  * @returns 매칭된 메시지들
  */
-export async function searchHistory(chatId, query, limit = 10) {
+export async function searchHistory(chatId, query, limit = MESSAGES.SEARCH_LIMIT) {
     const all = await loadHistory(chatId, 0); // 전부 로드
     const lowerQuery = query.toLowerCase();
     const matches = all

package/dist/session/state.js

@@ -1,27 +1,21 @@
 import { AsyncLocalStorage } from "async_hooks";
 import { estimateMessagesTokens, estimateTokens } from "../utils/tokens.js";
 import * as persistence from "./persistence.js";
-// 세션 설정
-const MAX_SESSIONS = 100;
-const SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24시간
-// 토큰 한도 (개선됨)
-const MAX_HISTORY_TOKENS = 40000; // 히스토리 한도
-const SUMMARY_THRESHOLD_TOKENS = 25000; // 이 이상이면 요약 시작
-const MIN_RECENT_MESSAGES = 6; // 최소 유지할 최근 메시지
-const MAX_PINNED_TOKENS = 5000; // 핀 맥락 최대 토큰
-// 영구 저장 설정
-const MAX_HISTORY_LOAD = 50; // 메모리에 로드할 최대 메시지 수
+import { SESSION, TOKENS, MESSAGES } from "../config/constants.js";
+import { getConfig } from "../config/index.js";
 // 세션별 상태 저장
 const sessions = new Map();
 // AsyncLocalStorage for chatId context
 const chatIdStorage = new AsyncLocalStorage();
 function getSession(chatId) {
+    const config = getConfig();
     // chatId 유효성 검사
     if (chatId == null || isNaN(chatId)) {
         console.error(`[Session] BUG: Invalid chatId: ${chatId} - history will NOT persist!`);
         return {
             history: [],
             model: "sonnet",
+            thinkingLevel: config.thinking,
             lastAccessedAt: Date.now(),
             pinnedContexts: [],
             summaryChunks: [],
@@ -36,12 +30,14 @@ function getSession(chatId) {
             existing.pinnedContexts = [];
         if (!existing.summaryChunks)
             existing.summaryChunks = [];
+        if (!existing.thinkingLevel)
+            existing.thinkingLevel = config.thinking;
         return existing;
     }
     // 새 세션 생성 전 정리
     cleanupSessions();
     // 기존 JSONL 파일에서 히스토리 로드
-    const persistedMessages = persistence.loadHistorySync(chatId, MAX_HISTORY_LOAD);
+    const persistedMessages = persistence.loadHistorySync(chatId, SESSION.MAX_HISTORY_LOAD);
     const history = persistedMessages.map(pm => ({
         role: pm.role,
         content: pm.content,
@@ -53,6 +49,7 @@ function getSession(chatId) {
     const session = {
         history,
         model: "sonnet",
+        thinkingLevel: config.thinking,
         lastAccessedAt: now,
         pinnedContexts: [],
         summaryChunks: [],
@@ -65,15 +62,15 @@ function cleanupSessions() {
     const now = Date.now();
     // 1. TTL 만료된 세션 삭제
     for (const [chatId, session] of sessions) {
-        if (now - session.lastAccessedAt > SESSION_TTL_MS) {
+        if (now - session.lastAccessedAt > SESSION.TTL_MS) {
             sessions.delete(chatId);
         }
     }
     // 2. 최대 개수 초과 시 LRU 방식으로 삭제
-    if (sessions.size >= MAX_SESSIONS) {
+    if (sessions.size >= SESSION.MAX_SESSIONS) {
         const entries = Array.from(sessions.entries());
         entries.sort((a, b) => a[1].lastAccessedAt - b[1].lastAccessedAt);
-        const toRemove = entries.slice(0, sessions.size - MAX_SESSIONS + 1);
+        const toRemove = entries.slice(0, sessions.size - SESSION.MAX_SESSIONS + 1);
         for (const [chatId] of toRemove) {
             sessions.delete(chatId);
         }
@@ -123,10 +120,10 @@ export function pinContext(chatId, text, source = "user") {
     const currentTokens = session.pinnedContexts.reduce((sum, p) => sum + estimateTokens(p.text), 0);
     const newTokens = estimateTokens(text);
     // 토큰 한도 체크
-    if (currentTokens + newTokens > MAX_PINNED_TOKENS) {
+    if (currentTokens + newTokens > TOKENS.MAX_PINNED) {
         // 오래된 자동 핀부터 제거
         while (session.pinnedContexts.length > 0 &&
-            currentTokens + newTokens > MAX_PINNED_TOKENS) {
+            currentTokens + newTokens > TOKENS.MAX_PINNED) {
             const autoIndex = session.pinnedContexts.findIndex((p) => p.source === "auto");
             if (autoIndex >= 0) {
                 session.pinnedContexts.splice(autoIndex, 1);
@@ -168,8 +165,8 @@ export function clearPins(chatId) {
 export function addSummaryChunk(chatId, chunk) {
     const session = getSession(chatId);
     session.summaryChunks.push(chunk);
-    // 오래된 요약은 병합 (최대 3개 유지)
-    while (session.summaryChunks.length > 3) {
+    // 오래된 요약은 병합
+    while (session.summaryChunks.length > MESSAGES.MAX_SUMMARY_CHUNKS) {
         const [first, second] = session.summaryChunks.splice(0, 2);
         session.summaryChunks.unshift({
             summary: `${first.summary}\n\n${second.summary}`,
@@ -193,12 +190,12 @@ export function trimHistoryByTokens(history) {
     }
     const currentTokens = estimateMessagesTokens(history);
     // 한도 이내면 패스
-    if (currentTokens <= MAX_HISTORY_TOKENS) {
+    if (currentTokens <= TOKENS.MAX_HISTORY) {
         return;
     }
     console.log(`[Trim] Starting trim: ${currentTokens} tokens, ${history.length} messages`);
     // 최근 메시지는 반드시 유지
-    while (estimateMessagesTokens(history) > MAX_HISTORY_TOKENS && history.length > MIN_RECENT_MESSAGES) {
+    while (estimateMessagesTokens(history) > TOKENS.MAX_HISTORY && history.length > MESSAGES.MIN_RECENT) {
         history.shift();
     }
     const afterTokens = estimateMessagesTokens(history);
@@ -219,7 +216,7 @@ export async function smartTrimHistory(chatId, summarizeFn) {
     }
     const currentTokens = estimateMessagesTokens(history);
     // 요약 임계치 이하면 패스
-    if (currentTokens <= SUMMARY_THRESHOLD_TOKENS) {
+    if (currentTokens <= TOKENS.SUMMARY_THRESHOLD) {
         return false;
     }
     // 요약 함수가 없으면 기본 트리밍만
@@ -228,9 +225,9 @@ export async function smartTrimHistory(chatId, summarizeFn) {
         return false;
     }
     console.log(`[SmartTrim] chatId=${chatId} tokens=${currentTokens}, starting summarization...`);
-    // 오래된 메시지들 (최근 6개 제외)
-    const toSummarize = history.slice(0, -MIN_RECENT_MESSAGES);
-    const toKeep = history.slice(-MIN_RECENT_MESSAGES);
+    // 오래된 메시지들 (최근 N개 제외)
+    const toSummarize = history.slice(0, -MESSAGES.MIN_RECENT);
+    const toKeep = history.slice(-MESSAGES.MIN_RECENT);
     if (toSummarize.length < 4) {
         // 요약할 게 별로 없으면 기본 트리밍
         trimHistoryByTokens(history);
@@ -334,6 +331,12 @@ export function getModel(chatId) {
 export function setModel(chatId, modelId) {
     getSession(chatId).model = modelId;
 }
+export function getThinkingLevel(chatId) {
+    return getSession(chatId).thinkingLevel;
+}
+export function setThinkingLevel(chatId, level) {
+    getSession(chatId).thinkingLevel = level;
+}
 export function runWithChatId(chatId, fn) {
     return chatIdStorage.run(chatId, fn);
 }

package/dist/telegram/handlers/commands.js

@@ -2,6 +2,7 @@ import { randomBytes } from "crypto";
 import { getHealthStatus, formatUptime } from "../../health/index.js";
 import { chat, MODELS } from "../../ai/claude.js";
 import { estimateMessagesTokens } from "../../utils/tokens.js";
+import { TOKENS, MESSAGES, MEMORY, SECURITY, TELEGRAM } from "../../config/constants.js";
 // 대화 요약 생성 함수
 async function generateSummary(messages) {
     const conversationText = messages.map(m => {
@@ -32,7 +33,7 @@ ${conversationText}
 const resetTokens = new Map();
 function generateResetToken(chatId) {
     const token = randomBytes(8).toString("hex");
-    const expiresAt = Date.now() + 60000; // 1분 후 만료
+    const expiresAt = Date.now() + SECURITY.RESET_TOKEN_TTL_MS;
     resetTokens.set(chatId, { token, expiresAt });
     return token;
 }
@@ -149,26 +150,26 @@ export function registerCommands(bot) {
         }
         // 현재 토큰 수 계산
         const currentTokens = estimateMessagesTokens(history);
-        // 메시지 개수가 적고 토큰도 적으면 스킵 (5000 토큰 = 약 한글 3000자)
+        // 메시지 개수가 적고 토큰도 적으면 스킵
         // 단, 토큰이 많으면 메시지 개수와 관계없이 compact 허용
-        if (history.length <= 4 && currentTokens < 5000) {
+        if (history.length <= MESSAGES.KEEP_ON_COMPACT && currentTokens < TOKENS.COMPACT_MIN_TOKENS) {
             await ctx.reply(`현재 ${history.length}개 메시지, ~${currentTokens} 토큰이라 충분히 짧아!`);
             return;
         }
         await ctx.replyWithChatAction("typing");
         await ctx.reply(`📊 현재: ${history.length}개 메시지, ~${currentTokens} 토큰\n요약 생성 중...`);
         // 요약할 메시지와 유지할 최근 메시지 분리
-        // 메시지가 4개 이하면 (토큰이 많아서 여기 온 경우) 전체 요약 후 마지막만 유지
+        // 메시지가 적으면 (토큰이 많아서 여기 온 경우) 전체 요약 후 마지막만 유지
         let recentMessages;
         let oldMessages;
-        if (history.length <= 4) {
+        if (history.length <= MESSAGES.KEEP_ON_COMPACT) {
             // 토큰이 많아서 compact 진입한 경우: 전체 요약 → 마지막 1개만 유지
             recentMessages = history.slice(-1);
             oldMessages = history.slice(0, -1);
         }
         else {
-            // 일반 경우: 마지막 4개 유지
-            recentMessages = history.slice(-4);
+            // 일반 경우: 마지막 N개 유지
+            recentMessages = history.slice(-MESSAGES.KEEP_ON_COMPACT);
             oldMessages = history.slice(0, -4);
         }
         // 요약 생성
@@ -189,16 +190,16 @@ export function registerCommands(bot) {
     });
     // /memory 명령어 - 최근 기억 보기
     bot.command("memory", async (ctx) => {
-        const memories = await loadRecentMemories(7);
+        const memories = await loadRecentMemories(MEMORY.DISPLAY_DAYS);
         if (!memories.trim()) {
             await ctx.reply("아직 기억해둔 게 없어!");
             return;
         }
         // 너무 길면 자르기
-        const truncated = memories.length > 2000
-            ? memories.slice(0, 2000) + "\n\n... (더 있음)"
+        const truncated = memories.length > MEMORY.MAX_DISPLAY_LENGTH
+            ? memories.slice(0, MEMORY.MAX_DISPLAY_LENGTH) + "\n\n... (더 있음)"
             : memories;
-        await ctx.reply(`📝 최근 일주일 기억:\n\n${truncated}`);
+        await ctx.reply(`📝 최근 ${MEMORY.DISPLAY_DAYS}일 기억:\n\n${truncated}`);
     });
     // /model 명령어 - 모델 변경
     bot.command("model", async (ctx) => {
@@ -449,7 +450,7 @@ export function registerCommands(bot) {
                 try {
                     const events = await getTodayEvents();
                     const preview = events.length > 0
-                        ? events.slice(0, 3).map(formatEvent).join("\n")
+                        ? events.slice(0, TELEGRAM.CALENDAR_PREVIEW_COUNT).map(formatEvent).join("\n")
                         : "오늘 일정 없음";
                     await ctx.reply(`📅 Google Calendar 연동됨!\n\n` +
                         `오늘 일정:\n${preview}\n\n` +

package/dist/telegram/handlers/messages.js

@@ -1,12 +1,11 @@
 import { chat, chatSmart } from "../../ai/claude.js";
 import { recordActivity, recordError } from "../../health/index.js";
-import { getHistory, getModel, runWithChatId, trimHistoryByTokens, smartTrimHistory, detectImportantContext, pinContext, addMessage, } from "../../session/state.js";
+import { getHistory, getModel, getThinkingLevel, runWithChatId, trimHistoryByTokens, smartTrimHistory, detectImportantContext, pinContext, addMessage, } from "../../session/state.js";
 import * as persistence from "../../session/persistence.js";
 import { updateLastMessageTime } from "../../heartbeat/index.js";
 import { extractUrls, fetchWebContent, formatUrlContent, buildSystemPrompt, } from "../utils/index.js";
 import { estimateMessagesTokens } from "../../utils/tokens.js";
-const MAX_CONTEXT_TOKENS = 100000; // Claude 컨텍스트
-const COMPACTION_THRESHOLD = 0.35; // 35% (35,000 토큰) - MAX_HISTORY_TOKENS(50k)보다 먼저 트리거되도록
+import { TOKENS, TELEGRAM } from "../../config/constants.js";
 /**
  * 토큰 사용량이 임계치를 넘으면 자동으로 히스토리 압축
  * 실패해도 메시지 처리에 영향 없도록 에러를 조용히 처리
@@ -14,8 +13,8 @@ const COMPACTION_THRESHOLD = 0.35; // 35% (35,000 토큰) - MAX_HISTORY_TOKENS(5
 async function autoCompactIfNeeded(ctx, history) {
     try {
         const tokens = estimateMessagesTokens(history);
-        const usage = tokens / MAX_CONTEXT_TOKENS;
-        if (usage > COMPACTION_THRESHOLD && history.length > 6) {
+        const usage = tokens / TOKENS.MAX_CONTEXT;
+        if (usage > TOKENS.COMPACTION_THRESHOLD && history.length > 6) {
             // 자동 compaction 실행
             console.log(`[AutoCompact] chatId=${ctx.chat?.id} usage=${(usage * 100).toFixed(1)}% - compacting...`);
             // 앞부분 요약 생성 (최근 4개 메시지 제외)
@@ -42,16 +41,16 @@ async function autoCompactIfNeeded(ctx, history) {
 /**
  * 스트리밍 응답 전송 (Telegram 메시지 실시간 업데이트)
  */
-async function sendStreamingResponse(ctx, messages, systemPrompt, modelId) {
+async function sendStreamingResponse(ctx, messages, systemPrompt, modelId, thinkingLevel) {
     // 1. 먼저 "..." 플레이스홀더 메시지 전송
     const placeholder = await ctx.reply("...");
     const chatId = ctx.chat.id;
     const messageId = placeholder.message_id;
     let lastUpdate = Date.now();
-    const UPDATE_INTERVAL = 500; // 0.5초마다 업데이트 (Telegram rate limit 고려)
+    const UPDATE_INTERVAL = TELEGRAM.STREAM_UPDATE_INTERVAL_MS;
     let lastText = "";
     try {
-        const result = await chatSmart(messages, systemPrompt, modelId, async (_chunk, accumulated) => {
+        const result = await chatSmart(messages, systemPrompt, modelId, thinkingLevel, async (_chunk, accumulated) => {
             const now = Date.now();
             // 0.5초마다 또는 충분히 변경되었을 때 업데이트
             if (now - lastUpdate > UPDATE_INTERVAL && accumulated !== lastText) {
@@ -109,6 +108,7 @@ export function registerMessageHandlers(bot) {
             recordActivity();
             const history = getHistory(chatId);
             const modelId = getModel(chatId);
+            const thinkingLevel = getThinkingLevel(chatId);
             await ctx.replyWithChatAction("typing");
             try {
                 // 가장 큰 사진 선택 (마지막이 가장 큼)
@@ -118,10 +118,10 @@ export function registerMessageHandlers(bot) {
                     await ctx.reply("사진을 가져올 수 없어.");
                     return;
                 }
-                // 파일 크기 제한 (10MB)
-                const MAX_IMAGE_SIZE = 10 * 1024 * 1024;
-                if (file.file_size && file.file_size > MAX_IMAGE_SIZE) {
-                    await ctx.reply("사진이 너무 커. 10MB 이하로 보내줄래?");
+                // 파일 크기 제한
+                if (file.file_size && file.file_size > TELEGRAM.MAX_IMAGE_SIZE) {
+                    const maxMb = Math.floor(TELEGRAM.MAX_IMAGE_SIZE / (1024 * 1024));
+                    await ctx.reply(`사진이 너무 커. ${maxMb}MB 이하로 보내줄래?`);
                     return;
                 }
                 // 파일 다운로드
@@ -152,7 +152,7 @@ export function registerMessageHandlers(bot) {
                 persistence.appendMessage(chatId, "user", `[이미지] ${caption}`);
                 try {
                     const systemPrompt = await buildSystemPrompt(modelId, history);
-                    const result = await chat(history, systemPrompt, modelId);
+                    const result = await chat(history, systemPrompt, modelId, thinkingLevel);
                     // 도구 사용 정보를 포함한 응답 기록
                     let assistantContent = result.text;
                     if (result.toolsUsed.length > 0) {
@@ -221,6 +221,7 @@ export function registerMessageHandlers(bot) {
             updateLastMessageTime(chatId);
             const history = getHistory(chatId);
             const modelId = getModel(chatId);
+            const thinkingLevel = getThinkingLevel(chatId);
             // 중요 맥락 자동 감지 및 핀
             const importantContext = detectImportantContext(userMessage);
             if (importantContext) {
@@ -233,7 +234,7 @@ export function registerMessageHandlers(bot) {
             let messageForHistory = userMessage;
             let urlContextForApi = ""; // 현재 요청에만 주입될 URL 내용
             if (urls.length > 0) {
-                const urlsToFetch = urls.slice(0, 3); // 최대 3개 URL
+                const urlsToFetch = urls.slice(0, TELEGRAM.MAX_URL_FETCH);
                 const contents = await Promise.all(urlsToFetch.map((url) => fetchWebContent(url)));
                 const urlRefs = [];
                 for (let i = 0; i < contents.length; i++) {
@@ -268,7 +269,7 @@ export function registerMessageHandlers(bot) {
                 }
                 // 스트리밍 응답 사용 (실시간 업데이트)
                 const response = await sendStreamingResponse(ctx, messagesForApi, // URL 내용이 포함된 버전
-                systemPrompt, modelId);
+                systemPrompt, modelId, thinkingLevel);
                 // 메모리 + JSONL에 영구 저장
                 addMessage(chatId, "assistant", response);
                 // 스마트 트리밍 (요약 포함) - autoCompactIfNeeded 대체

package/dist/telegram/utils/prompt.js

@@ -5,6 +5,7 @@ import { getWorkspace } from "./cache.js";
 import { embed } from "../../memory/embeddings.js";
 import { search } from "../../memory/vectorStore.js";
 import { buildContextForPrompt, getCurrentChatId } from "../../session/state.js";
+import { SEARCH_CONTEXT_LENGTH, PROMPT_MEMORY_SEARCH_LIMIT, PROMPT_MEMORY_MIN_SCORE, MEMORY_PREVIEW_LENGTH, } from "../../utils/constants.js";
 import * as os from "os";
 function getRuntimeInfo(modelId) {
     const model = MODELS[modelId];
@@ -61,7 +62,7 @@ function extractSearchContext(history) {
         .filter((m) => m.role === "user")
         .map((m) => (typeof m.content === "string" ? m.content : ""))
         .join(" ")
-        .slice(0, 500);
+        .slice(0, SEARCH_CONTEXT_LENGTH);
 }
 async function getRelevantMemories(history) {
     try {
@@ -69,11 +70,11 @@ async function getRelevantMemories(history) {
         if (!context.trim())
             return "";
         const queryEmbedding = await embed(context);
-        const results = await search(queryEmbedding, 3, 0.4);
+        const results = await search(queryEmbedding, PROMPT_MEMORY_SEARCH_LIMIT, PROMPT_MEMORY_MIN_SCORE);
         if (results.length === 0)
             return "";
         return results
-            .map((r) => `- (${r.source}): ${r.text.slice(0, 200)}${r.text.length > 200 ? "..." : ""}`)
+            .map((r) => `- (${r.source}): ${r.text.slice(0, MEMORY_PREVIEW_LENGTH)}${r.text.length > MEMORY_PREVIEW_LENGTH ? "..." : ""}`)
             .join("\n");
     }
     catch {

package/dist/utils/constants.js

@@ -42,3 +42,23 @@ export const MAX_SEARCH_RESULTS = 20;
 // ============== Memory ==============
 export const DEFAULT_MEMORY_SEARCH_LIMIT = 5;
 export const DEFAULT_MEMORY_MIN_SCORE = 0.3;
+/** Memory preview length in search results */
+export const MEMORY_PREVIEW_LENGTH = 200;
+/** Context extraction length for memory search */
+export const SEARCH_CONTEXT_LENGTH = 500;
+/** Memory search limit for prompt context (fewer, more relevant) */
+export const PROMPT_MEMORY_SEARCH_LIMIT = 3;
+/** Minimum score for prompt memory search (stricter) */
+export const PROMPT_MEMORY_MIN_SCORE = 0.4;
+// ============== Token Estimation ==============
+/** Tokens per Korean character (보수적 추정) */
+export const TOKENS_PER_KOREAN_CHAR = 1.5;
+/** Characters per token for non-Korean text */
+export const CHARS_PER_TOKEN_OTHER = 4;
+/** Per-message token overhead */
+export const MESSAGE_TOKEN_OVERHEAD = 4;
+// ============== Tool Usage Logging ==============
+/** Max length for tool input summary in history */
+export const TOOL_INPUT_SUMMARY_LENGTH = 200;
+/** Max length for tool output summary in history */
+export const TOOL_OUTPUT_SUMMARY_LENGTH = 500;

package/dist/utils/tokens.js

@@ -7,15 +7,16 @@
  *
  * These are rough estimates for context management, not exact counts.
  */
+import { TOKENS_PER_KOREAN_CHAR, CHARS_PER_TOKEN_OTHER, MESSAGE_TOKEN_OVERHEAD, } from "./constants.js";
 /**
  * Estimate token count for a text string
- * 한글은 보수적으로 1.5 토큰/글자로 계산 (실제보다 약간 높게)
+ * 한글은 보수적으로 계산 (실제보다 약간 높게)
  */
 export function estimateTokens(text) {
     // 자모음까지 포함하는 넓은 범위의 한글 매칭
     const koreanChars = (text.match(/[\u3131-\uD79D]/g) || []).length;
     const otherChars = text.length - koreanChars;
-    return Math.ceil(koreanChars * 1.5 + otherChars / 4);
+    return Math.ceil(koreanChars * TOKENS_PER_KOREAN_CHAR + otherChars / CHARS_PER_TOKEN_OTHER);
 }
 /**
  * Estimate token count for an array of messages
@@ -25,6 +26,6 @@ export function estimateMessagesTokens(messages) {
         const content = typeof msg.content === 'string'
             ? msg.content
             : JSON.stringify(msg.content);
-        return sum + estimateTokens(content) + 4; // 메시지 오버헤드
+        return sum + estimateTokens(content) + MESSAGE_TOKEN_OVERHEAD;
     }, 0);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "companionbot",
-  "version": "0.10.1",
+  "version": "0.11.1",
   "description": "AI 친구 텔레그램 봇 - Claude API 기반 개인화된 대화 상대",
   "keywords": [
     "telegram",