companionbot 0.8.2 → 0.10.0

package/dist/memory/vectorStore.js

@@ -1,6 +1,7 @@
 /**
  * 간단한 벡터 저장소 모듈
  * 메모리 파일들을 로드하고 유사도 기반으로 검색합니다.
+ * 임베딩은 파일에 캐시되어 재시작 후에도 유지됩니다.
  */
 import * as fs from "fs/promises";
 import * as path from "path";
@@ -10,8 +11,61 @@ import { embed, embedBatch, cosineSimilarity } from "./embeddings.js";
 let cachedChunks = [];
 let cacheTimestamp = 0;
 const CACHE_TTL_MS = 5 * 60 * 1000; // 5분
+// 임베딩 영속 캐시 (hash → embedding)
+let embeddingCache = new Map();
+let embeddingCacheLoaded = false;
 // 로딩 중복 방지용 Promise
 let loadingPromise = null;
+/**
+ * 간단한 해시 함수 (텍스트 변경 감지용)
+ */
+function simpleHash(text) {
+    let hash = 0;
+    for (let i = 0; i < text.length; i++) {
+        const char = text.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // 32bit 정수로 변환
+    }
+    return hash.toString(16);
+}
+/**
+ * 임베딩 캐시 파일 경로
+ */
+function getEmbeddingCachePath() {
+    return path.join(getMemoryDirPath(), ".embedding-cache.json");
+}
+/**
+ * 임베딩 캐시를 파일에서 로드합니다.
+ */
+async function loadEmbeddingCache() {
+    if (embeddingCacheLoaded)
+        return;
+    try {
+        const cachePath = getEmbeddingCachePath();
+        const data = await fs.readFile(cachePath, "utf-8");
+        const parsed = JSON.parse(data);
+        embeddingCache = new Map(Object.entries(parsed));
+        console.log(`[VectorStore] Loaded ${embeddingCache.size} cached embeddings`);
+    }
+    catch {
+        // 파일 없거나 파싱 실패 - 새로 시작
+        embeddingCache = new Map();
+    }
+    embeddingCacheLoaded = true;
+}
+/**
+ * 임베딩 캐시를 파일에 저장합니다.
+ */
+async function saveEmbeddingCache() {
+    try {
+        const cachePath = getEmbeddingCachePath();
+        const obj = Object.fromEntries(embeddingCache);
+        await fs.writeFile(cachePath, JSON.stringify(obj), "utf-8");
+    }
+    catch (error) {
+        console.warn("[VectorStore] Failed to save embedding cache:", error);
+    }
+}
 /**
  * 텍스트를 적절한 크기의 청크로 분할합니다.
  */
@@ -30,7 +84,11 @@ function splitIntoChunks(text, source) {
             for (const line of lines) {
                 if (currentChunk.length + line.length > 500) {
                     if (currentChunk.trim()) {
-                        chunks.push({ text: currentChunk.trim(), source });
+                        chunks.push({
+                            text: currentChunk.trim(),
+                            source,
+                            hash: simpleHash(currentChunk.trim())
+                        });
                     }
                     currentChunk = line;
                 }
@@ -39,11 +97,19 @@ function splitIntoChunks(text, source) {
                 }
             }
             if (currentChunk.trim()) {
-                chunks.push({ text: currentChunk.trim(), source });
+                chunks.push({
+                    text: currentChunk.trim(),
+                    source,
+                    hash: simpleHash(currentChunk.trim())
+                });
             }
         }
         else {
-            chunks.push({ text: trimmed, source });
+            chunks.push({
+                text: trimmed,
+                source,
+                hash: simpleHash(trimmed)
+            });
         }
     }
     return chunks;
@@ -52,12 +118,14 @@ function splitIntoChunks(text, source) {
  * 내부 로드 로직 - 실제 파일 로드 수행
  */
 async function doLoadAllMemoryChunks() {
+    // 임베딩 캐시 로드
+    await loadEmbeddingCache();
     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);
+        const mdFiles = files.filter(f => f.endsWith(".md") && !f.startsWith(".")).sort().reverse().slice(0, 30);
         for (const file of mdFiles) {
             try {
                 const content = await fs.readFile(path.join(memoryDir, file), "utf-8");
@@ -82,6 +150,15 @@ async function doLoadAllMemoryChunks() {
     catch {
         // 파일 없음 무시
     }
+    // 3. 캐시된 임베딩 복원
+    for (const chunk of chunks) {
+        if (chunk.hash) {
+            const cachedEmbedding = embeddingCache.get(chunk.hash);
+            if (cachedEmbedding) {
+                chunk.embedding = cachedEmbedding;
+            }
+        }
+    }
     return chunks;
 }
 /**
@@ -131,24 +208,35 @@ export async function search(queryEmbedding, topK = 5, minScore = 0.3) {
     // 임베딩이 없는 청크들을 배치로 처리
     const chunksNeedingEmbedding = chunks.filter(c => !c.embedding);
     if (chunksNeedingEmbedding.length > 0) {
+        console.log(`[VectorStore] Generating embeddings for ${chunksNeedingEmbedding.length} chunks`);
         try {
             const texts = chunksNeedingEmbedding.map(c => c.text);
             const embeddings = await embedBatch(texts);
-            // 임베딩 할당
+            // 임베딩 할당 및 캐시 저장
             for (let i = 0; i < chunksNeedingEmbedding.length; i++) {
-                chunksNeedingEmbedding[i].embedding = embeddings[i];
+                const chunk = chunksNeedingEmbedding[i];
+                chunk.embedding = embeddings[i];
+                if (chunk.hash) {
+                    embeddingCache.set(chunk.hash, embeddings[i]);
+                }
             }
+            // 캐시 파일 저장 (비동기, 실패해도 무시)
+            saveEmbeddingCache().catch(() => { });
         }
         catch {
             // 배치 실패 시 개별 처리 폴백
             for (const chunk of chunksNeedingEmbedding) {
                 try {
                     chunk.embedding = await embed(chunk.text);
+                    if (chunk.hash) {
+                        embeddingCache.set(chunk.hash, chunk.embedding);
+                    }
                 }
                 catch {
                     // 개별 실패 무시
                 }
             }
+            saveEmbeddingCache().catch(() => { });
         }
     }
     // 유사도 계산 및 필터링
@@ -172,12 +260,27 @@ export async function search(queryEmbedding, topK = 5, minScore = 0.3) {
 }
 /**
  * 캐시를 무효화합니다.
+ * 임베딩 캐시는 유지 (텍스트 해시 기반이므로)
  */
 export function invalidateCache() {
     cachedChunks = [];
     cacheTimestamp = 0;
     loadingPromise = null;
 }
+/**
+ * 임베딩 캐시까지 완전 초기화합니다.
+ */
+export async function clearAllCaches() {
+    invalidateCache();
+    embeddingCache.clear();
+    embeddingCacheLoaded = false;
+    try {
+        await fs.unlink(getEmbeddingCachePath());
+    }
+    catch {
+        // 파일 없으면 무시
+    }
+}
 // 인메모리 저장소 (간단한 구현)
 let vectorStore = [];
 /**

package/dist/session/persistence.js

@@ -0,0 +1,194 @@
+/**
+ * JSONL 기반 세션 영구 저장
+ *
+ * OpenClaw 스타일로 대화 기록을 JSONL 파일로 저장
+ * - 저장 경로: ~/.companionbot/sessions/{chatId}.jsonl
+ * - 메시지마다 한 줄씩 append
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as readline from "readline";
+// 저장 경로
+const SESSIONS_DIR = path.join(os.homedir(), ".companionbot", "sessions");
+/**
+ * 세션 디렉토리 초기화 (없으면 생성)
+ */
+function ensureSessionsDir() {
+    if (!fs.existsSync(SESSIONS_DIR)) {
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+        console.log(`[Persistence] Created sessions directory: ${SESSIONS_DIR}`);
+    }
+}
+/**
+ * chatId에 해당하는 JSONL 파일 경로
+ */
+function getSessionFilePath(chatId) {
+    return path.join(SESSIONS_DIR, `${chatId}.jsonl`);
+}
+/**
+ * 메시지를 JSONL 파일에 append
+ */
+export function appendMessage(chatId, role, content) {
+    ensureSessionsDir();
+    const filePath = getSessionFilePath(chatId);
+    const message = {
+        role,
+        content,
+        timestamp: Date.now(),
+    };
+    const line = JSON.stringify(message) + "\n";
+    try {
+        fs.appendFileSync(filePath, line, "utf-8");
+    }
+    catch (error) {
+        console.error(`[Persistence] Failed to append message to ${filePath}:`, error);
+    }
+}
+/**
+ * JSONL 파일에서 히스토리 로드
+ *
+ * @param chatId 채팅 ID
+ * @param limit 최근 N개만 로드 (메모리 절약, 0 = 전부)
+ * @returns 로드된 메시지 배열
+ */
+export async function loadHistory(chatId, limit = 100) {
+    const filePath = getSessionFilePath(chatId);
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    const messages = [];
+    try {
+        const fileStream = fs.createReadStream(filePath, { encoding: "utf-8" });
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            if (line.trim()) {
+                try {
+                    const msg = JSON.parse(line);
+                    messages.push(msg);
+                }
+                catch (parseError) {
+                    console.warn(`[Persistence] Skipping malformed line in ${filePath}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(`[Persistence] Failed to load history from ${filePath}:`, error);
+        return [];
+    }
+    // limit이 0이면 전부, 아니면 최근 N개만
+    if (limit > 0 && messages.length > limit) {
+        return messages.slice(-limit);
+    }
+    return messages;
+}
+/**
+ * 동기 버전 히스토리 로드 (초기화 시 사용)
+ */
+export function loadHistorySync(chatId, limit = 100) {
+    const filePath = getSessionFilePath(chatId);
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    const messages = [];
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        for (const line of lines) {
+            if (line.trim()) {
+                try {
+                    const msg = JSON.parse(line);
+                    messages.push(msg);
+                }
+                catch (parseError) {
+                    console.warn(`[Persistence] Skipping malformed line in ${filePath}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(`[Persistence] Failed to load history from ${filePath}:`, error);
+        return [];
+    }
+    // limit이 0이면 전부, 아니면 최근 N개만
+    if (limit > 0 && messages.length > limit) {
+        return messages.slice(-limit);
+    }
+    return messages;
+}
+/**
+ * 전체 히스토리 개수 (파일에서)
+ */
+export function getHistoryCount(chatId) {
+    const filePath = getSessionFilePath(chatId);
+    if (!fs.existsSync(filePath)) {
+        return 0;
+    }
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return content.split("\n").filter(line => line.trim()).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * 세션 파일 삭제 (히스토리 완전 삭제)
+ */
+export function deleteSessionFile(chatId) {
+    const filePath = getSessionFilePath(chatId);
+    if (!fs.existsSync(filePath)) {
+        return false;
+    }
+    try {
+        fs.unlinkSync(filePath);
+        console.log(`[Persistence] Deleted session file: ${filePath}`);
+        return true;
+    }
+    catch (error) {
+        console.error(`[Persistence] Failed to delete session file:`, error);
+        return false;
+    }
+}
+/**
+ * 세션 파일 존재 여부
+ */
+export function sessionFileExists(chatId) {
+    return fs.existsSync(getSessionFilePath(chatId));
+}
+/**
+ * 모든 세션 파일 목록
+ */
+export function listSessionFiles() {
+    ensureSessionsDir();
+    try {
+        const files = fs.readdirSync(SESSIONS_DIR);
+        return files
+            .filter(f => f.endsWith(".jsonl"))
+            .map(f => parseInt(f.replace(".jsonl", ""), 10))
+            .filter(id => !isNaN(id));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 히스토리 검색 (파일 전체에서)
+ *
+ * @param chatId 채팅 ID
+ * @param query 검색어
+ * @param limit 최대 결과 수
+ * @returns 매칭된 메시지들
+ */
+export async function searchHistory(chatId, query, limit = 10) {
+    const all = await loadHistory(chatId, 0); // 전부 로드
+    const lowerQuery = query.toLowerCase();
+    const matches = all
+        .filter(msg => msg.content.toLowerCase().includes(lowerQuery))
+        .slice(-limit); // 최근 것부터
+    return matches;
+}