companionbot 0.5.0 → 0.7.0

package/dist/cron/scheduler.js

@@ -7,7 +7,8 @@
 import { getDueJobs, markJobExecuted, loadJobs, addJob, removeJob, updateJob, getJobsByChat } from "./store.js";
 import { chat } from "../ai/claude.js";
 import { buildSystemPrompt } from "../telegram/utils/prompt.js";
-import { runWithChatId } from "../session/state.js";
+import { INTERVAL_1_MINUTE } from "../utils/time.js";
+import { TELEGRAM_SAFE_LIMIT } from "../utils/constants.js";
 // Scheduler state
 let schedulerInterval = null;
 let botInstance = null;
@@ -37,7 +38,7 @@ export class CronScheduler {
         // Then check every minute
         this.interval = setInterval(() => {
             this.checkAndRun().catch((err) => console.error("[CronScheduler] Check failed:", err));
-        }, 60 * 1000); // 1 minute
+        }, INTERVAL_1_MINUTE);
         console.log("[CronScheduler] Started - checking every minute");
     }
     /**
@@ -146,8 +147,7 @@ async function executeSystemEvent(job, payload, bot) {
  */
 async function executeAgentTurn(job, payload, bot) {
     const { message: inputMessage, context } = payload;
-    // Wrap in runWithChatId so tools can access chatId via getCurrentChatId()
-    const response = await runWithChatId(job.chatId, async () => {
+    try {
         // Build a fresh conversation for this job (separate from main chat)
         const messages = [
             {
@@ -167,25 +167,26 @@ async function executeAgentTurn(job, payload, bot) {
 - Run Count: ${(job.runCount || 0) + 1}
 - This is a scheduled task, not a direct user message.`;
         // Call Claude API
-        return await chat(messages, systemPrompt, "sonnet");
-    });
-    // Send the response to the chat
-    try {
-        if (response && response.trim()) {
+        const response = await chat(messages, systemPrompt, "sonnet");
+        // Send the response to the chat
+        const trimmedResponse = response?.trim();
+        if (trimmedResponse) {
             // Split long messages (Telegram limit is 4096 characters)
-            const maxLength = 4000;
-            if (response.length <= maxLength) {
-                await bot.api.sendMessage(job.chatId, response, {
+            const maxLength = TELEGRAM_SAFE_LIMIT;
+            if (trimmedResponse.length <= maxLength) {
+                await bot.api.sendMessage(job.chatId, trimmedResponse, {
                     parse_mode: "Markdown",
                 });
             }
             else {
                 // Split into multiple messages
-                const chunks = splitMessage(response, maxLength);
+                const chunks = splitMessage(trimmedResponse, maxLength);
                 for (const chunk of chunks) {
-                    await bot.api.sendMessage(job.chatId, chunk, {
-                        parse_mode: "Markdown",
-                    });
+                    if (chunk) {
+                        await bot.api.sendMessage(job.chatId, chunk, {
+                            parse_mode: "Markdown",
+                        });
+                    }
                 }
             }
         }
@@ -206,6 +207,10 @@ async function executeAgentTurn(job, payload, bot) {
  * Split a long message into chunks
  */
 function splitMessage(text, maxLength) {
+    // null/undefined/빈 문자열 처리
+    if (!text || text.trim().length === 0) {
+        return [];
+    }
     const chunks = [];
     let remaining = text;
     while (remaining.length > 0) {
@@ -328,3 +333,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/cron/store.js

@@ -6,13 +6,11 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { getWorkspacePath } from "../workspace/paths.js";
+import { sleep } from "../utils/time.js";
+import { LOCK_TIMEOUT_MS, LOCK_RETRY_MS, LOCK_MAX_RETRIES } from "../utils/constants.js";
 const CRON_FILE = "cron-jobs.json";
 const LOCK_FILE = "cron-jobs.lock";
 const STORE_VERSION = 1;
-// Lock configuration
-const LOCK_TIMEOUT_MS = 5000;
-const LOCK_RETRY_MS = 50;
-const LOCK_MAX_RETRIES = 100;
 function getCronFilePath() {
     return path.join(getWorkspacePath(), CRON_FILE);
 }
@@ -73,9 +71,6 @@ async function releaseLock() {
         // Ignore errors on unlock
     }
 }
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 /**
  * Execute a function with file lock protection
  */
@@ -94,13 +89,39 @@ async function withLock(fn) {
 async function loadJobsInternal() {
     try {
         const data = await fs.readFile(getCronFilePath(), "utf-8");
+        // 빈 파일 체크
+        if (!data || data.trim() === "") {
+            return [];
+        }
         const store = JSON.parse(data);
-        return store.jobs || [];
+        // jobs 배열 유효성 검사
+        if (!store || !Array.isArray(store.jobs)) {
+            console.warn("[Cron] Invalid store format, returning empty array");
+            return [];
+        }
+        return store.jobs;
     }
     catch (error) {
         if (error.code === "ENOENT") {
             return [];
         }
+        // JSON 파싱 오류
+        if (error instanceof SyntaxError) {
+            console.error("[Cron] Corrupted cron-jobs.json file:", error.message);
+            // 백업 파일 생성 시도
+            try {
+                const backupPath = `${getCronFilePath()}.corrupted.${Date.now()}`;
+                const data = await fs.readFile(getCronFilePath(), "utf-8").catch(() => "");
+                if (data) {
+                    await fs.writeFile(backupPath, data, "utf-8");
+                    console.log(`[Cron] Corrupted file backed up to: ${backupPath}`);
+                }
+            }
+            catch {
+                // 백업 실패는 무시
+            }
+            return [];
+        }
         console.error("[Cron] Failed to load jobs:", error);
         return [];
     }
@@ -446,12 +467,21 @@ function getDaysInMonth(year, month) {
  * Parse cron field like "1,3,5" or "1-5" or step values into array of numbers
  */
 function parseCronField(field, min, max) {
-    if (field === "*") {
+    // 빈 문자열/null/undefined 처리
+    if (!field || field.trim() === "") {
+        return Array.from({ length: max - min + 1 }, (_, i) => i + min); // wildcard로 처리
+    }
+    const trimmedField = field.trim();
+    if (trimmedField === "*") {
         return Array.from({ length: max - min + 1 }, (_, i) => i + min);
     }
     // Handle step values like */5
-    if (field.startsWith("*/")) {
-        const step = parseInt(field.slice(2), 10);
+    if (trimmedField.startsWith("*/")) {
+        const step = parseInt(trimmedField.slice(2), 10);
+        if (isNaN(step) || step <= 0) {
+            console.warn(`[Cron] Invalid step value in field: ${field}, using default`);
+            return Array.from({ length: max - min + 1 }, (_, i) => i + min);
+        }
         const values = [];
         for (let i = min; i <= max; i += step) {
             values.push(i);
@@ -459,39 +489,66 @@ function parseCronField(field, min, max) {
         return values;
     }
     const values = [];
-    const parts = field.split(",");
+    const parts = trimmedField.split(",");
     for (const part of parts) {
-        if (part.includes("-")) {
-            const [start, end] = part.split("-").map(Number);
-            for (let i = start; i <= end; i++) {
-                values.push(i);
+        const trimmedPart = part.trim();
+        if (!trimmedPart)
+            continue;
+        if (trimmedPart.includes("-") && !trimmedPart.includes("/")) {
+            const [startStr, endStr] = trimmedPart.split("-");
+            const start = Number(startStr);
+            const end = Number(endStr);
+            if (!isNaN(start) && !isNaN(end)) {
+                for (let i = start; i <= end; i++) {
+                    values.push(i);
+                }
             }
         }
-        else if (part.includes("/")) {
+        else if (trimmedPart.includes("/")) {
             // Handle range with step like 0-30/5
-            const [range, stepStr] = part.split("/");
+            const [range, stepStr] = trimmedPart.split("/");
             const step = parseInt(stepStr, 10);
+            if (isNaN(step) || step <= 0)
+                continue;
             let rangeStart = min;
             let rangeEnd = max;
-            if (range.includes("-")) {
-                [rangeStart, rangeEnd] = range.split("-").map(Number);
+            if (range && range.includes("-")) {
+                const [rs, re] = range.split("-").map(Number);
+                if (!isNaN(rs))
+                    rangeStart = rs;
+                if (!isNaN(re))
+                    rangeEnd = re;
             }
             for (let i = rangeStart; i <= rangeEnd; i += step) {
                 values.push(i);
             }
         }
         else {
-            values.push(parseInt(part, 10));
+            const num = parseInt(trimmedPart, 10);
+            if (!isNaN(num)) {
+                values.push(num);
+            }
         }
     }
-    return values.filter((v) => v >= min && v <= max);
+    // 유효한 값이 없으면 wildcard로 폴백
+    const filtered = values.filter((v) => v >= min && v <= max);
+    return filtered.length > 0 ? filtered : Array.from({ length: max - min + 1 }, (_, i) => i + min);
 }
 /**
  * Get all jobs for a specific chat
  */
 export async function getJobsByChat(chatId) {
+    // null/undefined 처리
+    if (chatId == null) {
+        return [];
+    }
     const jobs = await loadJobs();
     const numericChatId = typeof chatId === "string" ? parseInt(chatId, 10) : chatId;
+    // NaN 체크
+    if (isNaN(numericChatId)) {
+        console.warn(`[Cron] Invalid chatId: ${chatId}`);
+        return [];
+    }
     return jobs.filter((j) => j.chatId === numericChatId);
 }
 /**

package/dist/health/index.js

@@ -0,0 +1,66 @@
+/**
+ * 봇 헬스 체크 모듈
+ * 봇의 상태를 추적하고 모니터링합니다.
+ * @module health
+ */
+let startTime = Date.now();
+let lastActivity = Date.now();
+let messageCount = 0;
+let errorCount = 0;
+/**
+ * 활동을 기록합니다.
+ * 메시지 처리 시 호출하여 마지막 활동 시간과 메시지 카운트를 업데이트합니다.
+ */
+export function recordActivity() {
+    lastActivity = Date.now();
+    messageCount++;
+}
+/**
+ * 오류 발생을 기록합니다.
+ */
+export function recordError() {
+    errorCount++;
+}
+/**
+ * 현재 봇의 건강 상태를 조회합니다.
+ * @returns 건강 상태 정보
+ */
+export function getHealthStatus() {
+    const now = Date.now();
+    const uptime = Math.floor((now - startTime) / 1000);
+    const inactiveTime = now - lastActivity;
+    // 30분 이상 활동 없으면 unhealthy
+    const isHealthy = inactiveTime < 30 * 60 * 1000;
+    return {
+        uptime,
+        lastActivity,
+        messageCount,
+        errorCount,
+        isHealthy
+    };
+}
+/**
+ * 가동 시간을 읽기 좋은 형태로 포맷합니다.
+ * @param seconds - 가동 시간 (초)
+ * @returns 포맷된 문자열 (예: "2일 3시간", "5시간 30분")
+ */
+export function formatUptime(seconds) {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const mins = Math.floor((seconds % 3600) / 60);
+    if (days > 0)
+        return `${days}일 ${hours}시간`;
+    if (hours > 0)
+        return `${hours}시간 ${mins}분`;
+    return `${mins}분`;
+}
+/**
+ * 헬스 상태를 초기화합니다.
+ * 테스트나 재시작 시 사용합니다.
+ */
+export function resetHealth() {
+    startTime = Date.now();
+    lastActivity = Date.now();
+    messageCount = 0;
+    errorCount = 0;
+}

package/dist/heartbeat/index.js

@@ -4,16 +4,21 @@ import { getWorkspacePath } from "../workspace/index.js";
 import { chat } from "../ai/claude.js";
 import { isCalendarConfigured, getTodayEvents, formatEvent } from "../calendar/index.js";
 import { getSecret } from "../config/secrets.js";
-import { runWithChatId } from "../session/state.js";
+import { checkForUpdates } from "../updates/index.js";
+import { INTERVAL_30_MINUTES, INTERVAL_24_HOURS, hoursToMs } from "../utils/time.js";
 // 활성 타이머
 const activeTimers = new Map();
 // 메모리 캐시: 타임스탬프는 메모리에만 유지하여 파일 쓰기 최소화
 // lastCheckAt, lastMessageAt은 디버깅 용도라 매번 저장할 필요 없음
 const timestampCache = new Map();
+// 업데이트 체크 캐시 (하루에 한 번만)
+let lastUpdateCheck = 0;
+let cachedUpdateInfo = null;
+const UPDATE_CHECK_INTERVAL = INTERVAL_24_HOURS;
 // 봇 인스턴스
 let botInstance = null;
 // 기본 간격: 30분
-const DEFAULT_INTERVAL_MS = 30 * 60 * 1000;
+const DEFAULT_INTERVAL_MS = INTERVAL_30_MINUTES;
 export function setHeartbeatBot(bot) {
     botInstance = bot;
 }
@@ -80,6 +85,21 @@ async function gatherContext() {
             // 무시
         }
     }
+    // 업데이트 체크 (하루에 한 번)
+    const timeSinceLastCheck = Date.now() - lastUpdateCheck;
+    if (timeSinceLastCheck > UPDATE_CHECK_INTERVAL) {
+        try {
+            cachedUpdateInfo = await checkForUpdates();
+            lastUpdateCheck = Date.now();
+            console.log(`[Heartbeat] Update check: current=${cachedUpdateInfo.current}, latest=${cachedUpdateInfo.latest}`);
+        }
+        catch (error) {
+            console.error("[Heartbeat] Update check failed:", error);
+        }
+    }
+    if (cachedUpdateInfo?.hasUpdate) {
+        parts.push(`🆕 업데이트 알림: CompanionBot ${cachedUpdateInfo.latest} 버전이 출시됨! (현재: ${cachedUpdateInfo.current})`);
+    }
     return parts.join("\n");
 }
 // Heartbeat 실행 - 메시지를 보냈으면 true 반환
@@ -121,10 +141,7 @@ ${context}
     ];
     let messageSent = false;
     try {
-        // Wrap in runWithChatId so tools can access chatId via getCurrentChatId()
-        const response = await runWithChatId(config.chatId, async () => {
-            return await chat(messages, systemPrompt, "haiku");
-        });
+        const response = await chat(messages, systemPrompt, "haiku");
         if (!response.trim().includes("HEARTBEAT_OK")) {
             await botInstance.api.sendMessage(config.chatId, response);
             console.log(`[Heartbeat] Sent message to ${config.chatId}`);
@@ -261,7 +278,7 @@ export async function runHeartbeatNow(chatId) {
             enabled: false,
             intervalMs: DEFAULT_INTERVAL_MS,
             lastCheckAt: Date.now(),
-            lastMessageAt: Date.now() - (8 * 60 * 60 * 1000), // 8시간 전으로 설정
+            lastMessageAt: Date.now() - hoursToMs(8), // 8시간 전으로 설정
         };
         return await executeHeartbeat(defaultConfig);
     }

package/dist/memory/embeddings.js

@@ -0,0 +1,113 @@
+/**
+ * 로컬 임베딩 생성 모듈
+ * @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) {
+    // null/undefined 처리
+    if (text == null) {
+        return new Array(384).fill(0);
+    }
+    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);
+}
+/**
+ * 여러 텍스트를 배치로 임베딩합니다.
+ * 병렬로 처리하여 성능 향상 (모델 내부에서 순차 처리되더라도 Promise 오버헤드 감소)
+ * @param texts 변환할 텍스트 배열
+ * @returns 임베딩 벡터 배열
+ */
+export async function embedBatch(texts) {
+    // null/undefined 배열 처리
+    if (!texts || texts.length === 0)
+        return [];
+    if (texts.length === 1)
+        return [await embed(texts[0])];
+    // 동시성 제한 (메모리 보호)
+    const CONCURRENCY = 5;
+    const results = new Array(texts.length);
+    for (let i = 0; i < texts.length; i += CONCURRENCY) {
+        const batch = texts.slice(i, i + CONCURRENCY);
+        const batchResults = await Promise.all(batch.map(text => embed(text)));
+        for (let j = 0; j < batchResults.length; j++) {
+            results[i + j] = batchResults[j];
+        }
+    }
+    return results;
+}
+/**
+ * 두 벡터 간의 코사인 유사도를 계산합니다.
+ *
+ * 최적화: embed()에서 normalize: true로 정규화된 벡터를 반환하므로,
+ * 정규화된 벡터의 경우 코사인 유사도 = 내적 (norm이 1이므로)
+ * normalized 파라미터가 true면 내적만 계산하여 성능 향상.
+ */
+export function cosineSimilarity(a, b, normalized = true) {
+    // null/undefined 또는 빈 배열 처리
+    if (!a || !b || a.length === 0 || b.length === 0)
+        return 0;
+    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())
+    };
+}