companionbot 0.4.3 → 0.6.0

package/dist/ai/claude.js

@@ -7,28 +7,59 @@ function getClient() {
     }
     return anthropic;
 }
+// 모델별 max_tokens 및 thinking budget 설정
+// 참고: Claude API에서 thinking + output이 모델 한도 초과하면 안 됨
 export const MODELS = {
-    sonnet: { id: "claude-sonnet-4-20250514", name: "Claude Sonnet 4" },
-    opus: { id: "claude-opus-4-20250514", name: "Claude Opus 4" },
-    haiku: { id: "claude-haiku-3-5-20241022", name: "Claude Haiku 3.5" },
+    haiku: {
+        id: "claude-haiku-3-5-20241022",
+        name: "Claude Haiku 3.5",
+        maxTokens: 4096, // 빠른 응답
+        thinkingBudget: 0, // Haiku는 thinking 미지원
+    },
+    sonnet: {
+        id: "claude-sonnet-4-20250514",
+        name: "Claude Sonnet 4",
+        maxTokens: 8192, // 일반 작업
+        thinkingBudget: 10000, // 적당한 thinking
+    },
+    opus: {
+        id: "claude-opus-4-20250514",
+        name: "Claude Opus 4",
+        maxTokens: 16384, // 복잡한 작업
+        thinkingBudget: 32000, // 깊은 thinking
+    },
 };
 export async function chat(messages, systemPrompt, modelId = "sonnet") {
     const client = getClient();
-    const model = MODELS[modelId].id;
+    const modelConfig = MODELS[modelId];
     // 메시지를 API 형식으로 변환
     const apiMessages = messages.map((m) => ({
         role: m.role,
         content: m.content,
     }));
-    let response;
-    try {
-        response = await client.messages.create({
-            model,
-            max_tokens: 4096,
-            system: systemPrompt,
+    // API 요청 파라미터 빌드 (도구 루프에서도 동일하게 사용)
+    const buildRequestParams = () => {
+        const params = {
+            model: modelConfig.id,
+            max_tokens: modelConfig.maxTokens,
             messages: apiMessages,
             tools: tools,
-        });
+        };
+        if (systemPrompt) {
+            params.system = systemPrompt;
+        }
+        // thinking 활성화 (budget > 0인 경우)
+        if (modelConfig.thinkingBudget > 0) {
+            params.thinking = {
+                type: "enabled",
+                budget_tokens: modelConfig.thinkingBudget,
+            };
+        }
+        return params;
+    };
+    let response;
+    try {
+        response = await client.messages.create(buildRequestParams());
     }
     catch (error) {
         if (error instanceof Anthropic.APIError) {
@@ -71,15 +102,9 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
             role: "user",
             content: toolResults,
         });
-        // 다음 응답 요청
+        // 다음 응답 요청 (도구 루프에서도 thinking 유지)
         try {
-            response = await client.messages.create({
-                model,
-                max_tokens: 4096,
-                system: systemPrompt,
-                messages: apiMessages,
-                tools: tools,
-            });
+            response = await client.messages.create(buildRequestParams());
         }
         catch (error) {
             if (error instanceof Anthropic.APIError) {
@@ -102,3 +127,90 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
     const textBlock = response.content.find((block) => block.type === "text");
     return textBlock?.text ?? "응답을 생성하지 못했어. 다시 시도해줄래?";
 }
+/**
+ * 스마트 채팅 - 가능하면 스트리밍, 도구 필요하면 일반 호출
+ *
+ * 전략:
+ * - 먼저 스트리밍으로 시도
+ * - 도구 호출이 감지되면 (stop_reason === "tool_use") 기존 chat()으로 폴백
+ * - 스트리밍은 최종 텍스트 응답에만 사용
+ */
+export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
+    // 스트리밍 콜백이 없으면 그냥 일반 chat 사용
+    if (!onChunk) {
+        const text = await chat(messages, systemPrompt, modelId);
+        return { text, usedTools: false };
+    }
+    const client = getClient();
+    const modelConfig = MODELS[modelId];
+    // 메시지를 API 형식으로 변환
+    const apiMessages = messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+    }));
+    // 스트리밍 요청 파라미터
+    const params = {
+        model: modelConfig.id,
+        max_tokens: modelConfig.maxTokens,
+        messages: apiMessages,
+        tools: tools,
+        stream: true,
+    };
+    if (systemPrompt) {
+        params.system = systemPrompt;
+    }
+    // Thinking은 스트리밍에서 복잡해지므로 일단 비활성화
+    // (도구 호출 폴백 시 chat()에서 thinking 사용됨)
+    let accumulated = "";
+    let stopReason = null;
+    try {
+        const stream = client.messages.stream(params);
+        // 스트리밍 이벤트 처리
+        stream.on("text", async (text) => {
+            accumulated += text;
+            try {
+                await onChunk(text, accumulated);
+            }
+            catch (err) {
+                // editMessageText 실패 등은 무시하고 계속
+                console.warn("[Stream] Chunk callback error (ignored):", err);
+            }
+        });
+        // 스트림 완료 대기
+        const finalMessage = await stream.finalMessage();
+        stopReason = finalMessage.stop_reason;
+        // 도구 호출이 필요한 경우 - 일반 chat으로 폴백
+        if (stopReason === "tool_use") {
+            console.log("[Stream] Tool use detected, falling back to chat()");
+            const text = await chat(messages, systemPrompt, modelId);
+            return { text, usedTools: true };
+        }
+        // 성공적으로 스트리밍 완료
+        return { text: accumulated, usedTools: false };
+    }
+    catch (error) {
+        // 스트리밍 에러 핸들링
+        if (error instanceof Anthropic.APIError) {
+            if (error.status === 429) {
+                throw new Error("API 요청이 너무 많아. 잠시 후 다시 시도해줘.");
+            }
+            if (error.status >= 500) {
+                throw new Error("AI 서버에 문제가 생겼어. 잠시 후 다시 시도해줘.");
+            }
+        }
+        // 연결 끊김 등 스트리밍 에러 - 이미 받은 내용이 있으면 반환 시도
+        if (accumulated.length > 50) {
+            console.warn("[Stream] Connection error, returning partial response");
+            return { text: accumulated + "\n\n(연결이 끊겨서 응답이 잘렸을 수 있어)", usedTools: false };
+        }
+        // 응답이 거의 없으면 일반 chat으로 재시도
+        console.warn("[Stream] Connection error, retrying with chat()");
+        try {
+            const text = await chat(messages, systemPrompt, modelId);
+            return { text, usedTools: false };
+        }
+        catch (retryError) {
+            throw retryError;
+        }
+    }
+}

package/dist/cron/index.js

@@ -8,7 +8,7 @@ export { isValidCronExpression, parseCronExpression, getNextCronRun, getNextRun,
 // Storage functions
 export { loadJobs, saveJobs, addJob, removeJob, updateJob, getDueJobs, markJobExecuted, getJobsByChat, getJob, calculateNextRun, } from "./store.js";
 // Scheduler functions
-export { CronScheduler, executeJob, setCronBot, startCronScheduler, stopCronScheduler, isCronSchedulerRunning, initCronSystem, restoreCronJobs, createCronJob, deleteCronJob, toggleCronJob, getCronJobs, getAllCronJobs, getActiveJobCount, } from "./scheduler.js";
+export { CronScheduler, executeJob, setCronBot, startCronScheduler, stopCronScheduler, isCronSchedulerRunning, initCronSystem, restoreCronJobs, createCronJob, deleteCronJob, toggleCronJob, getCronJobs, getAllCronJobs, getActiveJobCount, ensureDefaultCronJobs, } from "./scheduler.js";
 // Command handlers (for tools)
 export { addCronJob, removeCronJob, setCronJobEnabled, listCronJobs, getCronStatus, } from "./commands.js";
 // Aliases for backward compatibility

package/dist/cron/scheduler.js

@@ -324,3 +324,34 @@ export function getActiveJobCount() {
     // For actual count, use getAllCronJobs and filter
     return 0; // Placeholder - will be updated by scheduler
 }
+// ============================================================
+// Default Cron Jobs
+// ============================================================
+const DEFAULT_CRON_JOBS = [
+    {
+        name: "daily_memory_save",
+        cronExpr: "0 12 * * *", // 매일 12시
+        command: "오늘 하루 동안 있었던 중요한 일들을 정리해서 MEMORY.md에 저장해줘. 새로운 정보, 대화 내용, 배운 것들 위주로.",
+        timezone: "Asia/Seoul",
+    },
+];
+/**
+ * Ensure default cron jobs exist for a chat
+ * Call this after onboarding or on /start
+ */
+export async function ensureDefaultCronJobs(chatId) {
+    const existingJobs = await getJobsByChat(chatId);
+    for (const defaultJob of DEFAULT_CRON_JOBS) {
+        const exists = existingJobs.some(job => job.name === defaultJob.name);
+        if (!exists) {
+            await createCronJob({
+                chatId,
+                name: defaultJob.name,
+                cronExpr: defaultJob.cronExpr,
+                command: defaultJob.command,
+                timezone: defaultJob.timezone,
+            });
+            console.log(`[Cron] Added default job: ${defaultJob.name} for chat ${chatId}`);
+        }
+    }
+}

package/dist/memory/embeddings.js

@@ -0,0 +1,94 @@
+/**
+ * 로컬 임베딩 생성 모듈
+ * @xenova/transformers를 사용하여 텍스트 임베딩을 생성합니다.
+ */
+import { pipeline } from "@xenova/transformers";
+// 싱글톤 파이프라인
+let embeddingPipeline = null;
+// 모델 로딩 중인지 추적
+let isLoading = false;
+let loadingPromise = null;
+/**
+ * 임베딩 파이프라인을 초기화합니다.
+ * 작고 빠른 모델 사용 (384 차원)
+ */
+async function getEmbeddingPipeline() {
+    if (embeddingPipeline) {
+        return embeddingPipeline;
+    }
+    // 이미 로딩 중이면 기다림
+    if (isLoading && loadingPromise) {
+        return loadingPromise;
+    }
+    isLoading = true;
+    loadingPromise = pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2" // 384차원, 빠르고 가벼움
+    );
+    try {
+        embeddingPipeline = await loadingPromise;
+        return embeddingPipeline;
+    }
+    finally {
+        isLoading = false;
+    }
+}
+/**
+ * 텍스트를 임베딩 벡터로 변환합니다.
+ * @param text 변환할 텍스트
+ * @returns 384차원 임베딩 벡터
+ */
+export async function embed(text) {
+    const pipe = await getEmbeddingPipeline();
+    // 텍스트 정규화
+    const cleanText = text.trim().slice(0, 512); // 최대 512자
+    if (!cleanText) {
+        return new Array(384).fill(0);
+    }
+    const result = await pipe(cleanText, {
+        pooling: "mean",
+        normalize: true,
+    });
+    // Tensor를 배열로 변환
+    return Array.from(result.data);
+}
+/**
+ * 여러 텍스트를 배치로 임베딩합니다.
+ * @param texts 변환할 텍스트 배열
+ * @returns 임베딩 벡터 배열
+ */
+export async function embedBatch(texts) {
+    const results = [];
+    for (const text of texts) {
+        results.push(await embed(text));
+    }
+    return results;
+}
+/**
+ * 두 벡터 간의 코사인 유사도를 계산합니다.
+ *
+ * 최적화: embed()에서 normalize: true로 정규화된 벡터를 반환하므로,
+ * 정규화된 벡터의 경우 코사인 유사도 = 내적 (norm이 1이므로)
+ * normalized 파라미터가 true면 내적만 계산하여 성능 향상.
+ */
+export function cosineSimilarity(a, b, normalized = true) {
+    if (a.length !== b.length)
+        return 0;
+    let dotProduct = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+    }
+    // 정규화된 벡터면 내적 = 코사인 유사도
+    if (normalized) {
+        return dotProduct;
+    }
+    // 정규화되지 않은 벡터면 norm 계산 필요
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+    if (denominator === 0)
+        return 0;
+    return dotProduct / denominator;
+}

package/dist/memory/index.js

@@ -0,0 +1,4 @@
+// Memory module exports
+export { embed, embedBatch, cosineSimilarity } from './embeddings.js';
+export { search, invalidateCache } from './vectorStore.js';
+export { indexFile, indexMainMemory, indexDailyMemories, reindexAll } from './indexer.js';

package/dist/memory/indexer.js

@@ -0,0 +1,39 @@
+/**
+ * 메모리 인덱서 모듈
+ * 현재 구현은 vectorStore가 on-demand로 로드하므로 캐시 무효화만 수행
+ */
+import { invalidateCache } from './vectorStore.js';
+// 단일 파일 인덱싱 (캐시 무효화)
+export async function indexFile(_filePath, _source) {
+    // vectorStore가 on-demand로 로드하므로 캐시만 무효화
+    invalidateCache();
+    return 1;
+}
+// MEMORY.md 인덱싱
+export async function indexMainMemory() {
+    invalidateCache();
+    return 1;
+}
+// 일일 메모리 파일들 인덱싱
+export async function indexDailyMemories(_days = 30) {
+    invalidateCache();
+    return 1;
+}
+// 전체 리인덱싱 (캐시 무효화 후 미리 로드)
+export async function reindexAll() {
+    console.log('[Indexer] Invalidating cache for reindex...');
+    invalidateCache();
+    // 캐시 무효화 후 즉시 로드하여 청크 수 반환
+    // search를 임시로 호출하여 로드 트리거 (빈 쿼리로)
+    const { loadAllMemoryChunks } = await import('./vectorStore.js');
+    const chunks = await loadAllMemoryChunks();
+    // 소스별 집계
+    const sourceCounts = new Map();
+    for (const chunk of chunks) {
+        sourceCounts.set(chunk.source, (sourceCounts.get(chunk.source) || 0) + 1);
+    }
+    return {
+        total: chunks.length,
+        sources: Array.from(sourceCounts.keys())
+    };
+}

package/dist/memory/vectorStore.js

@@ -0,0 +1,194 @@
+/**
+ * 간단한 벡터 저장소 모듈
+ * 메모리 파일들을 로드하고 유사도 기반으로 검색합니다.
+ */
+import * as fs from "fs/promises";
+import * as path from "path";
+import { getMemoryDirPath, getWorkspaceFilePath } from "../workspace/paths.js";
+import { embed, cosineSimilarity } from "./embeddings.js";
+// 캐시된 청크들 (임베딩 포함)
+let cachedChunks = [];
+let cacheTimestamp = 0;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5분
+// 로딩 중복 방지용 Promise
+let loadingPromise = null;
+/**
+ * 텍스트를 적절한 크기의 청크로 분할합니다.
+ */
+function splitIntoChunks(text, source) {
+    const chunks = [];
+    // ## 헤더로 분할 (메모리 파일 형식)
+    const sections = text.split(/(?=^## )/m);
+    for (const section of sections) {
+        const trimmed = section.trim();
+        if (!trimmed || trimmed.length < 20)
+            continue;
+        // 청크가 너무 길면 추가로 분할
+        if (trimmed.length > 500) {
+            const lines = trimmed.split("\n");
+            let currentChunk = "";
+            for (const line of lines) {
+                if (currentChunk.length + line.length > 500) {
+                    if (currentChunk.trim()) {
+                        chunks.push({ text: currentChunk.trim(), source });
+                    }
+                    currentChunk = line;
+                }
+                else {
+                    currentChunk += "\n" + line;
+                }
+            }
+            if (currentChunk.trim()) {
+                chunks.push({ text: currentChunk.trim(), source });
+            }
+        }
+        else {
+            chunks.push({ text: trimmed, source });
+        }
+    }
+    return chunks;
+}
+/**
+ * 내부 로드 로직 - 실제 파일 로드 수행
+ */
+async function doLoadAllMemoryChunks() {
+    const chunks = [];
+    // 1. 일별 메모리 파일 (최근 30일)
+    const memoryDir = getMemoryDirPath();
+    try {
+        const files = await fs.readdir(memoryDir);
+        const mdFiles = files.filter(f => f.endsWith(".md")).sort().reverse().slice(0, 30);
+        for (const file of mdFiles) {
+            try {
+                const content = await fs.readFile(path.join(memoryDir, file), "utf-8");
+                const fileChunks = splitIntoChunks(content, file.replace(".md", ""));
+                chunks.push(...fileChunks);
+            }
+            catch {
+                // 파일 읽기 실패 무시
+            }
+        }
+    }
+    catch {
+        // 디렉토리 없음 무시
+    }
+    // 2. MEMORY.md (장기 기억)
+    try {
+        const memoryMdPath = getWorkspaceFilePath("MEMORY.md");
+        const content = await fs.readFile(memoryMdPath, "utf-8");
+        const memoryChunks = splitIntoChunks(content, "MEMORY");
+        chunks.push(...memoryChunks);
+    }
+    catch {
+        // 파일 없음 무시
+    }
+    return chunks;
+}
+/**
+ * 모든 메모리 파일을 로드하고 청크로 분할합니다.
+ * 동시 요청 시 중복 로드를 방지합니다.
+ */
+export async function loadAllMemoryChunks() {
+    const now = Date.now();
+    // 캐시가 유효하면 반환
+    if (cachedChunks.length > 0 && now - cacheTimestamp < CACHE_TTL_MS) {
+        return cachedChunks;
+    }
+    // 이미 로딩 중이면 해당 Promise 반환 (중복 로드 방지)
+    if (loadingPromise) {
+        return loadingPromise;
+    }
+    // 새로 로드
+    loadingPromise = doLoadAllMemoryChunks();
+    try {
+        const chunks = await loadingPromise;
+        // 캐시 업데이트 (임베딩은 아직 없음)
+        cachedChunks = chunks;
+        cacheTimestamp = Date.now();
+        return chunks;
+    }
+    finally {
+        loadingPromise = null;
+    }
+}
+/**
+ * 쿼리 임베딩으로 관련 메모리를 검색합니다.
+ * @param queryEmbedding 검색 쿼리의 임베딩 벡터
+ * @param topK 반환할 최대 결과 수
+ * @param minScore 최소 유사도 점수 (0-1)
+ */
+export async function search(queryEmbedding, topK = 5, minScore = 0.3) {
+    const chunks = await loadAllMemoryChunks();
+    if (chunks.length === 0) {
+        return [];
+    }
+    // 각 청크에 대해 임베딩 생성 및 유사도 계산
+    const results = [];
+    for (const chunk of chunks) {
+        try {
+            // 캐시된 임베딩이 없으면 생성
+            if (!chunk.embedding) {
+                chunk.embedding = await embed(chunk.text);
+            }
+            const score = cosineSimilarity(queryEmbedding, chunk.embedding);
+            if (score >= minScore) {
+                results.push({
+                    text: chunk.text,
+                    source: chunk.source,
+                    score,
+                });
+            }
+        }
+        catch {
+            // 임베딩 실패 무시
+        }
+    }
+    // 유사도 점수로 정렬하고 상위 K개 반환
+    return results
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topK);
+}
+/**
+ * 캐시를 무효화합니다.
+ */
+export function invalidateCache() {
+    cachedChunks = [];
+    cacheTimestamp = 0;
+    loadingPromise = null;
+}
+// 인메모리 저장소 (간단한 구현)
+let vectorStore = [];
+/**
+ * 엔트리들을 저장소에 추가/업데이트합니다.
+ */
+export async function upsertEntries(entries) {
+    for (const entry of entries) {
+        const existingIndex = vectorStore.findIndex(e => e.id === entry.id);
+        if (existingIndex >= 0) {
+            vectorStore[existingIndex] = entry;
+        }
+        else {
+            vectorStore.push(entry);
+        }
+    }
+    // 캐시 무효화
+    invalidateCache();
+}
+/**
+ * 특정 소스의 모든 엔트리를 삭제합니다.
+ */
+export async function deleteBySource(source) {
+    const before = vectorStore.length;
+    vectorStore = vectorStore.filter(e => e.source !== source);
+    const deleted = before - vectorStore.length;
+    if (deleted > 0) {
+        invalidateCache();
+    }
+    return deleted;
+}
+/**
+ * 저장소의 모든 엔트리를 반환합니다.
+ */
+export function getAllEntries() {
+    return [...vectorStore];
+}

package/dist/session/state.js

@@ -1,7 +1,9 @@
 import { AsyncLocalStorage } from "async_hooks";
+import { estimateMessagesTokens } from "../utils/tokens.js";
 // 세션 설정
 const MAX_SESSIONS = 100;
 const SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24시간
+const MAX_HISTORY_TOKENS = 50000; // 시스템 프롬프트 + 응답 여유 남기고
 // 세션별 상태 저장
 const sessions = new Map();
 // AsyncLocalStorage for chatId context
@@ -44,6 +46,15 @@ function cleanupSessions() {
 export function getHistory(chatId) {
     return getSession(chatId).history;
 }
+/**
+ * 히스토리를 토큰 기반으로 트리밍한다.
+ * 최대 토큰 한도를 초과하면 가장 오래된 메시지부터 제거 (최소 2개는 유지).
+ */
+export function trimHistoryByTokens(history) {
+    while (estimateMessagesTokens(history) > MAX_HISTORY_TOKENS && history.length > 2) {
+        history.shift();
+    }
+}
 export function clearHistory(chatId) {
     sessions.delete(chatId);
 }

package/dist/telegram/handlers/commands.js

@@ -1,5 +1,32 @@
 import { randomBytes } from "crypto";
 import { chat, MODELS } from "../../ai/claude.js";
+import { estimateMessagesTokens } from "../../utils/tokens.js";
+// 대화 요약 생성 함수
+async function generateSummary(messages) {
+    const conversationText = messages.map(m => {
+        const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+        return `${m.role === "user" ? "사용자" : "AI"}: ${content}`;
+    }).join("\n");
+    const summaryPrompt = [
+        {
+            role: "user",
+            content: `다음 대화를 핵심만 담아 간결하게 요약해줘. 중요한 결정사항, 사용자 정보, 맥락만 포함하고 3-5문장 이내로:
+
+${conversationText}
+
+요약:`
+        }
+    ];
+    try {
+        // haiku로 빠르게 요약 생성
+        const summary = await chat(summaryPrompt, undefined, "haiku");
+        return summary;
+    }
+    catch (error) {
+        console.error("Summary generation error:", error);
+        return "이전 대화 내용 (요약 생성 실패)";
+    }
+}
 // Reset 토큰 관리 (1분 만료)
 const resetTokens = new Map();
 function generateResetToken(chatId) {
@@ -29,6 +56,7 @@ import { isCalendarConfigured, hasCredentials, setCredentials, getAuthUrl, start
 import { setBriefingConfig, getBriefingConfig, disableBriefing, } from "../../briefing/index.js";
 import { setHeartbeatConfig, getHeartbeatConfig, disableHeartbeat, } from "../../heartbeat/index.js";
 import { getWorkspace, invalidateWorkspaceCache, buildSystemPrompt, extractName, } from "../utils/index.js";
+import { ensureDefaultCronJobs } from "../../cron/scheduler.js";
 export function registerCommands(bot) {
     // /start 명령어
     bot.command("start", async (ctx) => {
@@ -67,6 +95,8 @@ export function registerCommands(bot) {
             // 일반 모드
             const workspace = await getWorkspace();
             const name = extractName(workspace.identity) || "CompanionBot";
+            // 기본 cron jobs 설정 확인
+            await ensureDefaultCronJobs(chatId);
             await ctx.reply(`안녕! ${name}이야.\n\n` +
                 `명령어:\n` +
                 `/clear - 대화 초기화\n` +
@@ -114,10 +144,28 @@ export function registerCommands(bot) {
             await ctx.reply("아직 정리할 대화가 별로 없어!");
             return;
         }
-        // 최근 4개만 남기고 정리
-        const removed = history.length - 4;
-        history.splice(0, removed);
-        await ctx.reply(`대화 정리 완료! ${removed}개 메시지 압축했어.`);
+        // 현재 토큰 수 계산
+        const currentTokens = estimateMessagesTokens(history);
+        await ctx.replyWithChatAction("typing");
+        await ctx.reply(`📊 현재: ${history.length}개 메시지, ~${currentTokens} 토큰\n요약 생성 중...`);
+        // 요약할 메시지와 유지할 최근 메시지 분리
+        const recentMessages = history.slice(-4);
+        const oldMessages = history.slice(0, -4);
+        // 요약 생성
+        const summary = await generateSummary(oldMessages);
+        // 히스토리 교체: 요약 + 최근 4개
+        history.splice(0, history.length);
+        history.push({
+            role: "user",
+            content: `[이전 대화 요약]\n${summary}`
+        });
+        history.push(...recentMessages);
+        // 새 토큰 수 계산
+        const newTokens = estimateMessagesTokens(history);
+        const savedPercent = Math.round((1 - newTokens / currentTokens) * 100);
+        await ctx.reply(`✨ 대화 정리 완료!\n\n` +
+            `📉 ${currentTokens} → ${newTokens} 토큰\n` +
+            `💾 약 ${savedPercent}% 절약 (${oldMessages.length}개 → 요약 1개)`);
     });
     // /memory 명령어 - 최근 기억 보기
     bot.command("memory", async (ctx) => {

package/dist/telegram/handlers/messages.js

@@ -1,7 +1,54 @@
-import { chat } from "../../ai/claude.js";
-import { getHistory, getModel, runWithChatId, } from "../../session/state.js";
+import { chat, chatSmart } from "../../ai/claude.js";
+import { getHistory, getModel, runWithChatId, trimHistoryByTokens, } from "../../session/state.js";
 import { updateLastMessageTime } from "../../heartbeat/index.js";
 import { extractUrls, fetchWebContent, buildSystemPrompt, } from "../utils/index.js";
+/**
+ * 스트리밍 응답 전송 (Telegram 메시지 실시간 업데이트)
+ */
+async function sendStreamingResponse(ctx, messages, systemPrompt, modelId) {
+    // 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 고려)
+    let lastText = "";
+    const result = await chatSmart(messages, systemPrompt, modelId, async (_chunk, accumulated) => {
+        const now = Date.now();
+        // 0.5초마다 또는 충분히 변경되었을 때 업데이트
+        if (now - lastUpdate > UPDATE_INTERVAL && accumulated !== lastText) {
+            try {
+                await ctx.api.editMessageText(chatId, messageId, accumulated + " ▌");
+                lastUpdate = now;
+                lastText = accumulated;
+            }
+            catch {
+                // rate limit 등 무시
+            }
+        }
+    });
+    // 도구를 사용한 경우 스트리밍이 안됐으므로 새 응답 전송
+    if (result.usedTools) {
+        // placeholder 메시지를 최종 결과로 교체
+        try {
+            await ctx.api.editMessageText(chatId, messageId, result.text);
+        }
+        catch {
+            // 실패시 새 메시지로 전송
+            await ctx.api.deleteMessage(chatId, messageId);
+            await ctx.reply(result.text);
+        }
+        return result.text;
+    }
+    // 최종 메시지 업데이트 (커서 제거)
+    try {
+        await ctx.api.editMessageText(chatId, messageId, result.text);
+    }
+    catch {
+        // 이미 동일 텍스트면 에러 발생 가능 - 무시
+    }
+    return result.text;
+}
 /**
  * 메시지 핸들러들을 봇에 등록합니다.
  */
@@ -50,14 +97,19 @@ export function registerMessageHandlers(bot) {
                     },
                 ];
                 history.push({ role: "user", content: imageContent });
-                const systemPrompt = await buildSystemPrompt(modelId);
-                const result = await chat(history, systemPrompt, modelId);
-                history.push({ role: "assistant", content: result });
-                // 히스토리 제한
-                if (history.length > 20) {
-                    history.splice(0, history.length - 20);
+                try {
+                    const systemPrompt = await buildSystemPrompt(modelId, history);
+                    const result = await chat(history, systemPrompt, modelId);
+                    history.push({ role: "assistant", content: result });
+                    // 토큰 기반 히스토리 트리밍
+                    trimHistoryByTokens(history);
+                    await ctx.reply(result);
+                }
+                catch (innerError) {
+                    // 에러 시 방금 추가한 사용자 메시지 롤백 (히스토리 오염 방지)
+                    history.pop();
+                    throw innerError;
                 }
-                await ctx.reply(result);
             }
             catch (error) {
                 console.error("Photo error:", error);
@@ -98,16 +150,16 @@ export function registerMessageHandlers(bot) {
             // 사용자 메시지 추가 (URL 내용 포함)
             history.push({ role: "user", content: enrichedMessage });
             try {
-                const systemPrompt = await buildSystemPrompt(modelId);
-                const response = await chat(history, systemPrompt, modelId);
+                const systemPrompt = await buildSystemPrompt(modelId, history);
+                // 스트리밍 응답 사용 (실시간 업데이트)
+                const response = await sendStreamingResponse(ctx, history, systemPrompt, modelId);
                 history.push({ role: "assistant", content: response });
-                // 히스토리 제한 (최근 20개 메시지만 유지)
-                if (history.length > 20) {
-                    history.splice(0, history.length - 20);
-                }
-                await ctx.reply(response);
+                // 토큰 기반 히스토리 트리밍
+                trimHistoryByTokens(history);
             }
             catch (error) {
+                // 에러 시 방금 추가한 사용자 메시지 롤백 (히스토리 오염 방지)
+                history.pop();
                 console.error("Chat error:", error);
                 await ctx.reply("뭔가 잘못됐어. 다시 시도해줄래?");
             }

package/dist/telegram/utils/prompt.js

@@ -1,7 +1,9 @@
 import { MODELS } from "../../ai/claude.js";
-import { loadRecentMemories, getWorkspacePath } from "../../workspace/index.js";
+import { getWorkspacePath } from "../../workspace/index.js";
 import { getToolsDescription } from "../../tools/index.js";
 import { getWorkspace } from "./cache.js";
+import { embed } from "../../memory/embeddings.js";
+import { search } from "../../memory/vectorStore.js";
 /**
  * identity.md에서 이름을 추출합니다.
  */
@@ -17,16 +19,78 @@ export function extractName(identityContent) {
     }
     return null;
 }
+/**
+ * 최근 대화에서 검색 쿼리 컨텍스트를 추출합니다.
+ */
+function extractSearchContext(history) {
+    const recent = history.slice(-3);
+    return recent
+        .filter((m) => m.role === "user")
+        .map((m) => (typeof m.content === "string" ? m.content : ""))
+        .join(" ")
+        .slice(0, 500);
+}
+/**
+ * 대화 컨텍스트와 관련된 메모리를 검색합니다.
+ */
+async function getRelevantMemories(history) {
+    try {
+        const context = extractSearchContext(history);
+        if (!context.trim())
+            return "";
+        const queryEmbedding = await embed(context);
+        const results = await search(queryEmbedding, 3, 0.4); // 상위 3개, 유사도 0.4 이상
+        if (results.length === 0)
+            return "";
+        return ("\n\n## 관련 기억\n" +
+            results
+                .map((r) => `- (${r.source}): ${r.text.slice(0, 200)}${r.text.length > 200 ? "..." : ""}`)
+                .join("\n"));
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * 현재 날짜/시간을 한국어 포맷으로 반환합니다.
+ */
+function getKoreanDateTime() {
+    const now = new Date();
+    const timezone = "Asia/Seoul";
+    const formatter = new Intl.DateTimeFormat("ko-KR", {
+        timeZone: timezone,
+        year: "numeric",
+        month: "long",
+        day: "numeric",
+        weekday: "short",
+        hour: "numeric",
+        minute: "2-digit",
+        hour12: true,
+    });
+    const formatted = formatter.format(now);
+    return {
+        formatted,
+        timezone: `${timezone} (GMT+9)`,
+    };
+}
 /**
  * 시스템 프롬프트를 동적으로 생성합니다.
+ * @param modelId 사용할 모델 ID
+ * @param history 대화 히스토리 (관련 메모리 검색에 사용)
  */
-export async function buildSystemPrompt(modelId) {
+export async function buildSystemPrompt(modelId, history) {
     const model = MODELS[modelId];
     const workspace = await getWorkspace();
     const parts = [];
     // 기본 정보
     parts.push(`You are a personal AI companion running on ${model.name}.`);
     parts.push(`Workspace: ${getWorkspacePath()}`);
+    // 런타임 정보 (날짜/시간)
+    const dateTime = getKoreanDateTime();
+    parts.push(`Current time: ${dateTime.formatted}`);
+    parts.push(`Timezone: ${dateTime.timezone}`);
+    // 채널/플랫폼 정보
+    parts.push(`Runtime: channel=telegram | capabilities=markdown,inline_keyboard,reactions | version=0.4.x`);
     // BOOTSTRAP 모드인 경우
     if (workspace.bootstrap) {
         parts.push("---");
@@ -53,12 +117,14 @@ export async function buildSystemPrompt(modelId) {
             parts.push("---");
             parts.push(workspace.agents);
         }
-        // 최근 기억 로드
-        const recentMemories = await loadRecentMemories(3);
-        if (recentMemories.trim()) {
-            parts.push("---");
-            parts.push("# 최근 기억");
-            parts.push(recentMemories);
+        // 관련 기억 로드 (대화 컨텍스트 기반)
+        if (history && history.length > 0) {
+            const relevantMemories = await getRelevantMemories(history);
+            if (relevantMemories) {
+                parts.push("---");
+                parts.push("# 관련 기억");
+                parts.push(relevantMemories);
+            }
         }
         if (workspace.memory) {
             parts.push("---");

package/dist/tools/index.js

@@ -14,8 +14,11 @@ import { isCalendarConfigured, getEvents, addEvent, deleteEvent, formatEvent, pa
 import { setHeartbeatConfig, getHeartbeatConfig, disableHeartbeat, runHeartbeatNow, } from "../heartbeat/index.js";
 import { setBriefingConfig, getBriefingConfig, disableBriefing, sendBriefingNow, } from "../briefing/index.js";
 import { spawnAgent, listAgents, cancelAgent, } from "../agents/index.js";
-import { addCronJob, listCronJobs, removeCronJob, setCronJobEnabled, runCronJobNow, parseScheduleExpression, } from "../cron/index.js";
+import { addCronJob, listCronJobs, removeCronJob, setCronJobEnabled, runCronJobNow, parseScheduleExpression, ensureDefaultCronJobs, } from "../cron/index.js";
 import * as cheerio from "cheerio";
+import { embed } from '../memory/embeddings.js';
+import { search } from '../memory/vectorStore.js';
+import { reindexAll } from '../memory/indexer.js';
 const execAsync = promisify(exec);
 // 메모리에 세션 저장
 const sessions = new Map();
@@ -782,6 +785,38 @@ Examples:
             required: ["id"],
         },
     },
+    // ============== 메모리 검색 ==============
+    {
+        name: "memory_search",
+        description: "Search through long-term memories using semantic similarity. Use this when the user asks about past conversations, events, or information that might be stored in memory.",
+        input_schema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search query - what to look for in memories"
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of results (default: 5)"
+                },
+                minScore: {
+                    type: "number",
+                    description: "Minimum similarity score 0-1 (default: 0.3). Lower = more results but less relevant."
+                }
+            },
+            required: ["query"]
+        }
+    },
+    {
+        name: "memory_reindex",
+        description: "Reindex all memory files. Use when memories seem outdated or after major memory updates.",
+        input_schema: {
+            type: "object",
+            properties: {},
+            required: []
+        }
+    },
 ];
 // Tool 실행 함수
 export async function executeTool(name, input) {
@@ -1046,6 +1081,11 @@ ${"─".repeat(40)}`;
                 await saveWorkspaceFile("USER.md", user);
                 // BOOTSTRAP.md 삭제
                 await deleteBootstrap();
+                // 기본 cron jobs 설정 (매일 12시 메모리 저장 등)
+                const chatId = getCurrentChatId();
+                if (chatId) {
+                    await ensureDefaultCronJobs(chatId);
+                }
                 return "Persona saved! BOOTSTRAP mode complete. I'm ready to chat with my new identity.";
             }
             case "get_weather": {
@@ -1554,6 +1594,25 @@ Next run: ${nextRunStr}`;
                     return `Error: Cron job ${id} not found.`;
                 }
             }
+            // ============== 메모리 검색 ==============
+            case "memory_search": {
+                const query = input.query;
+                const limit = input.limit || 5;
+                const minScore = input.minScore || 0.3;
+                const queryEmbedding = await embed(query);
+                const results = await search(queryEmbedding, limit, minScore);
+                if (results.length === 0) {
+                    return "관련 기억을 찾지 못했어.";
+                }
+                return results.map((r, i) => `[${i + 1}] (${r.source}, score: ${r.score.toFixed(2)})\n${r.text}`).join('\n\n---\n\n');
+            }
+            case "memory_reindex": {
+                const result = await reindexAll();
+                const sourceList = result.sources.length > 5
+                    ? result.sources.slice(0, 5).join(', ') + ` 외 ${result.sources.length - 5}개`
+                    : result.sources.join(', ');
+                return `리인덱싱 완료: 총 ${result.total}개 청크 (소스: ${sourceList || '없음'})`;
+            }
             default:
                 return `Error: Unknown tool: ${name}`;
         }
@@ -1632,5 +1691,9 @@ export function getToolsDescription(modelId) {
 - toggle_cron: cron job 활성화/비활성화 (id, enabled)
 - run_cron: cron job 즉시 실행 (id) - 테스트/수동 트리거용
 
+## 메모리 검색
+- memory_search: 장기 기억에서 시맨틱 검색 (query, limit)
+- memory_reindex: 메모리 파일 재인덱싱
+
 허용된 경로: ${path.join(home, "Documents")}, ${path.join(home, "projects")}, 워크스페이스`;
 }

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from './tokens.js';

package/dist/utils/tokens.js

@@ -0,0 +1,30 @@
+/**
+ * Token estimation utilities
+ *
+ * Claude roughly uses:
+ * - English: ~4 chars per token
+ * - Korean: ~1.5 tokens per char (한글은 토큰이 더 많이 필요함)
+ *
+ * These are rough estimates for context management, not exact counts.
+ */
+/**
+ * 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);
+}
+/**
+ * Estimate token count for an array of messages
+ */
+export function estimateMessagesTokens(messages) {
+    return messages.reduce((sum, msg) => {
+        const content = typeof msg.content === 'string'
+            ? msg.content
+            : JSON.stringify(msg.content);
+        return sum + estimateTokens(content) + 4; // 메시지 오버헤드
+    }, 0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "companionbot",
-  "version": "0.4.3",
+  "version": "0.6.0",
   "description": "AI 친구 텔레그램 봇 - Claude API 기반 개인화된 대화 상대",
   "keywords": [
     "telegram",
@@ -45,6 +45,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
     "@grammyjs/ratelimiter": "^1.2.1",
+    "@xenova/transformers": "^2.17.2",
     "cheerio": "^1.2.0",
     "googleapis": "^171.4.0",
     "grammy": "^1.31.0",

package/templates/AGENTS.md

@@ -53,6 +53,12 @@
 
 다양한 도구를 사용할 수 있어. 시스템이 자동으로 제공하니까 목록 외울 필요 없어.
 
+**언제 도구를 쓸지:**
+- 단순 질문: 도구 없이 바로 답변
+- 파일 작업: 확인 없이 바로 실행
+- 외부 작업 (웹 검색 등): 필요시 바로 실행
+- 위험한 작업 (삭제 등): 먼저 확인
+
 **기본 원칙:**
 - 대화가 먼저야 — 도구는 필요할 때만
 - 도구 이름 모르면 그냥 하고 싶은 거 말해
@@ -65,6 +71,24 @@
 - 날씨 조회
 - 스케줄링 (cron)
 
+## 도구 호출 스타일
+
+기본: 단순한 도구 호출은 설명 없이 바로 실행해.
+
+**설명 없이 바로 실행:**
+- 파일 읽기/쓰기
+- 웹 검색
+- 날씨 조회
+- 일정 확인
+
+**간단히 설명 후 실행:**
+- 여러 단계 작업
+- 복잡한 문제 해결
+- 민감한 작업 (삭제 등)
+
+❌ 나쁜 예: "네, 파일을 읽어볼게요. read_file 도구를 사용하겠습니다."
+✅ 좋은 예: (그냥 바로 read_file 호출)
+
 ## 💬 대화 스타일
 
 - **메신저 환경**이야. 짧고 명확하게.
@@ -72,6 +96,70 @@
 - 이모지 적절히 사용해도 됨.
 - 사용자 스타일에 맞춰.
 
+## 이모지 반응
+
+Telegram에서 이모지 반응 사용 가능해. 텍스트 응답 대신 반응만으로 충분할 때 사용해.
+
+**반응 사용 시:**
+- 👍 간단한 확인/동의
+- ❤️ 감사/공감
+- 😂 재미있을 때
+- 🔥 대단할 때
+- 🤔 생각 중일 때
+
+**주의:**
+- 모든 메시지에 반응하지 마
+- 반응 + 텍스트 둘 다 하지 마 (하나만)
+- 5-10개 메시지당 1번 정도가 적당
+
+## 그룹챗 행동
+
+그룹챗에서는 더 조심해.
+
+**말해야 할 때:**
+- 직접 멘션되었을 때
+- 내가 답할 수 있는 질문
+- 유용한 정보 추가할 수 있을 때
+
+**조용히 있어야 할 때:**
+- 사람들끼리 대화 중
+- 누군가 이미 답변함
+- 단순 잡담
+
+그룹에서는 참여하되, 지배하지 마.
+
+## 플랫폼 포맷팅
+
+### Telegram
+- 마크다운 지원 (볼드, 이탤릭, 코드블록)
+- 긴 메시지는 4096자 제한
+- 인라인 키보드 버튼 사용 가능
+- 이모지 자유롭게 사용 가능
+
+### 응답 스타일
+- 복잡한 정보는 bullet point로
+- 코드는 백틱으로 감싸기
+- 긴 응답은 섹션으로 나누기
+
+## 침묵 규칙
+
+모든 메시지에 응답할 필요 없어.
+
+**침묵해도 되는 경우:**
+- 하트비트 체크인데 할 일 없을 때 → `HEARTBEAT_OK`
+- 사용자가 혼잣말하는 것 같을 때
+- "ㅇㅇ", "ㅋㅋ" 같은 단순 반응
+- 이미 충분히 답변한 후 "고마워" 같은 인사
+
+**반드시 응답해야 하는 경우:**
+- 직접적인 질문
+- 도움 요청
+- 명령/지시
+- 중요한 정보 공유
+
+**HEARTBEAT_OK:**
+하트비트 메시지 받았는데 특별히 할 일 없으면 `HEARTBEAT_OK`만 응답.
+
 ## 💓 Heartbeat
 
 주기적으로 HEARTBEAT.md를 체크해. 할 일이 있으면 알려주고, 없으면 조용히 있어.