companionbot 0.8.2 → 0.10.0

package/dist/ai/claude.js

@@ -75,6 +75,7 @@ export const MODELS = {
 export async function chat(messages, systemPrompt, modelId = "sonnet") {
     const client = getClient();
     const modelConfig = MODELS[modelId];
+    const toolsUsed = [];
     // 메시지를 API 형식으로 변환
     const apiMessages = messages.map((m) => ({
         role: m.role,
@@ -122,6 +123,12 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
                 tool_use_id: toolUse.id,
                 content: truncatedResult,
             });
+            // 도구 사용 기록 (히스토리 참조용)
+            toolsUsed.push({
+                name: toolUse.name,
+                input: JSON.stringify(toolUse.input).slice(0, 200),
+                output: truncatedResult.slice(0, 500),
+            });
         }
         // 어시스턴트 메시지와 도구 결과 추가
         apiMessages.push({
@@ -138,11 +145,14 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
     // 반복 횟수 초과 시 경고
     if (iterations >= MAX_TOOL_ITERATIONS) {
         console.warn(`[Warning] Tool use loop reached max iterations (${MAX_TOOL_ITERATIONS})`);
-        return "도구 실행이 너무 많이 반복됐어. 다시 시도해줄래?";
+        return { text: "도구 실행이 너무 많이 반복됐어. 다시 시도해줄래?", toolsUsed };
     }
     // 최종 텍스트 응답 추출
     const textBlock = response.content.find((block) => block.type === "text");
-    return textBlock?.text ?? "응답을 생성하지 못했어. 다시 시도해줄래?";
+    return {
+        text: textBlock?.text ?? "응답을 생성하지 못했어. 다시 시도해줄래?",
+        toolsUsed
+    };
 }
 /**
  * 스마트 채팅 - 가능하면 스트리밍, 도구 필요하면 일반 호출
@@ -158,8 +168,8 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
 export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
     // 스트리밍 콜백이 없으면 그냥 일반 chat 사용
     if (!onChunk) {
-        const text = await chat(messages, systemPrompt, modelId);
-        return { text, usedTools: false };
+        const result = await chat(messages, systemPrompt, modelId);
+        return { text: result.text, usedTools: result.toolsUsed.length > 0, toolsUsed: result.toolsUsed };
     }
     const client = getClient();
     const modelConfig = MODELS[modelId];
@@ -204,11 +214,11 @@ 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 text = await chat(messages, systemPrompt, modelId);
-            return { text, usedTools: true };
+            const result = await chat(messages, systemPrompt, modelId);
+            return { text: result.text, usedTools: true, toolsUsed: result.toolsUsed };
         }
         // 성공적으로 스트리밍 완료
-        return { text: accumulated, usedTools: false };
+        return { text: accumulated, usedTools: false, toolsUsed: [] };
     }
     catch (error) {
         // 스트리밍 시작 전 에러 (연결 실패 등) - 재시도 가능
@@ -218,8 +228,8 @@ 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 text = await chat(messages, systemPrompt, modelId);
-                    return { text, usedTools: false };
+                    const result = await chat(messages, systemPrompt, modelId);
+                    return { text: result.text, usedTools: false, toolsUsed: result.toolsUsed };
                 });
             }
         }
@@ -230,7 +240,8 @@ export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
             if (accumulated.length > 0) {
                 return {
                     text: accumulated + "\n\n(응답 생성 중 오류 발생)",
-                    usedTools: false
+                    usedTools: false,
+                    toolsUsed: []
                 };
             }
         }

package/dist/cron/scheduler.js

@@ -167,9 +167,9 @@ 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
-        const response = await chat(messages, systemPrompt, "sonnet");
+        const result = await chat(messages, systemPrompt, "sonnet");
         // Send the response to the chat
-        const trimmedResponse = response?.trim();
+        const trimmedResponse = result.text?.trim();
         if (trimmedResponse) {
             // Split long messages (Telegram limit is 4096 characters)
             const maxLength = TELEGRAM_SAFE_LIMIT;

package/dist/heartbeat/index.js

@@ -141,9 +141,9 @@ ${context}
     ];
     let messageSent = false;
     try {
-        const response = await chat(messages, systemPrompt, "haiku");
-        if (!response.trim().includes("HEARTBEAT_OK")) {
-            await botInstance.api.sendMessage(config.chatId, response);
+        const result = await chat(messages, systemPrompt, "haiku");
+        if (!result.text.trim().includes("HEARTBEAT_OK")) {
+            await botInstance.api.sendMessage(config.chatId, result.text);
             console.log(`[Heartbeat] Sent message to ${config.chatId}`);
             messageSent = true;
             // 타임스탬프는 메모리 캐시에만 저장 (파일 쓰기 안 함)

package/dist/memory/ftsIndex.js

@@ -0,0 +1,148 @@
+/**
+ * FTS5 기반 키워드 검색 인덱스 모듈
+ * SQLite FTS5를 사용하여 전문 검색을 제공합니다.
+ */
+import Database from "better-sqlite3";
+import * as path from "path";
+import { getMemoryDirPath } from "../workspace/paths.js";
+// 싱글톤 DB 인스턴스
+let db = null;
+/**
+ * FTS5 데이터베이스 경로
+ */
+function getDbPath() {
+    return path.join(getMemoryDirPath(), ".fts-index.db");
+}
+/**
+ * 데이터베이스 인스턴스를 가져오거나 생성합니다.
+ */
+function getDb() {
+    if (db)
+        return db;
+    const dbPath = getDbPath();
+    db = new Database(dbPath);
+    // FTS5 테이블 생성 (없으면)
+    db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+      id,
+      source,
+      text,
+      content='',
+      tokenize='unicode61'
+    );
+  `);
+    return db;
+}
+/**
+ * 텍스트를 FTS 인덱스에 추가합니다.
+ * 기존 id가 있으면 업데이트합니다.
+ */
+export function indexText(id, source, text) {
+    const database = getDb();
+    // 기존 엔트리 삭제 후 삽입 (upsert)
+    const deleteStmt = database.prepare("DELETE FROM memory_fts WHERE id = ?");
+    const insertStmt = database.prepare("INSERT INTO memory_fts (id, source, text) VALUES (?, ?, ?)");
+    const transaction = database.transaction(() => {
+        deleteStmt.run(id);
+        insertStmt.run(id, source, text);
+    });
+    transaction();
+}
+/**
+ * 여러 텍스트를 배치로 인덱싱합니다.
+ */
+export function indexTextBatch(entries) {
+    if (entries.length === 0)
+        return;
+    const database = getDb();
+    const deleteStmt = database.prepare("DELETE FROM memory_fts WHERE id = ?");
+    const insertStmt = database.prepare("INSERT INTO memory_fts (id, source, text) VALUES (?, ?, ?)");
+    const transaction = database.transaction(() => {
+        for (const entry of entries) {
+            deleteStmt.run(entry.id);
+            insertStmt.run(entry.id, entry.source, entry.text);
+        }
+    });
+    transaction();
+}
+/**
+ * 키워드로 검색합니다.
+ * FTS5 MATCH 쿼리와 BM25 랭킹 사용
+ */
+export function searchKeyword(query, limit = 10) {
+    const database = getDb();
+    // 쿼리 정규화 (특수문자 제거, 공백으로 분리)
+    const cleanQuery = query
+        .replace(/[^\w\s가-힣]/g, " ")
+        .trim()
+        .split(/\s+/)
+        .filter(word => word.length > 0)
+        .map(word => `"${word}"`) // 정확한 단어 매칭
+        .join(" OR "); // OR 검색
+    if (!cleanQuery)
+        return [];
+    try {
+        const stmt = database.prepare(`
+      SELECT id, source, text, bm25(memory_fts) as score
+      FROM memory_fts
+      WHERE memory_fts MATCH ?
+      ORDER BY score
+      LIMIT ?
+    `);
+        const results = stmt.all(cleanQuery, limit);
+        return results.map(r => ({
+            id: r.id,
+            source: r.source,
+            text: r.text,
+            score: r.score,
+        }));
+    }
+    catch {
+        // 쿼리 파싱 실패 시 빈 결과
+        return [];
+    }
+}
+/**
+ * 특정 소스의 모든 엔트리를 삭제합니다.
+ */
+export function deleteBySource(source) {
+    const database = getDb();
+    const stmt = database.prepare("DELETE FROM memory_fts WHERE source = ?");
+    const result = stmt.run(source);
+    return result.changes;
+}
+/**
+ * 특정 ID의 엔트리를 삭제합니다.
+ */
+export function deleteById(id) {
+    const database = getDb();
+    const stmt = database.prepare("DELETE FROM memory_fts WHERE id = ?");
+    const result = stmt.run(id);
+    return result.changes > 0;
+}
+/**
+ * 전체 인덱스를 초기화합니다.
+ */
+export function clearIndex() {
+    const database = getDb();
+    database.exec("DELETE FROM memory_fts");
+}
+/**
+ * 인덱스의 총 문서 수를 반환합니다.
+ */
+export function getDocumentCount() {
+    const database = getDb();
+    const stmt = database.prepare("SELECT COUNT(*) as count FROM memory_fts");
+    const result = stmt.get();
+    return result.count;
+}
+/**
+ * 데이터베이스 연결을 닫습니다.
+ * 애플리케이션 종료 시 호출
+ */
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}

package/dist/memory/hybridSearch.js

@@ -0,0 +1,103 @@
+/**
+ * 하이브리드 검색 모듈
+ * 벡터 검색 + 키워드 검색을 결합하여 최적의 검색 결과를 제공합니다.
+ */
+import { embed } from "./embeddings.js";
+import { search as vectorSearch } from "./vectorStore.js";
+import { searchKeyword } from "./ftsIndex.js";
+// 가중치 설정
+const VECTOR_WEIGHT = 0.7;
+const KEYWORD_WEIGHT = 0.3;
+/**
+ * BM25 점수를 0-1 범위로 정규화합니다.
+ * BM25는 낮을수록 관련성이 높으므로 반전시킵니다.
+ */
+function normalizeBm25Score(score, minScore, maxScore) {
+    if (maxScore === minScore)
+        return 1;
+    // BM25는 음수 (낮을수록 좋음) → 정규화 후 반전
+    const normalized = (maxScore - score) / (maxScore - minScore);
+    return Math.max(0, Math.min(1, normalized));
+}
+/**
+ * 벡터 + 키워드 하이브리드 검색을 수행합니다.
+ *
+ * @param query 검색 쿼리
+ * @param topK 반환할 최대 결과 수
+ * @param vectorWeight 벡터 검색 가중치 (기본 0.7)
+ * @param keywordWeight 키워드 검색 가중치 (기본 0.3)
+ */
+export async function hybridSearch(query, topK = 5, vectorWeight = VECTOR_WEIGHT, keywordWeight = KEYWORD_WEIGHT) {
+    // 병렬로 두 검색 수행
+    const [queryEmbedding, keywordResults] = await Promise.all([
+        embed(query),
+        Promise.resolve(searchKeyword(query, topK * 2)), // 키워드 검색은 더 많이 가져옴
+    ]);
+    // 벡터 검색 수행
+    const vectorResults = await vectorSearch(queryEmbedding, topK * 2, 0.2);
+    // 결과가 모두 없으면 빈 배열 반환
+    if (vectorResults.length === 0 && keywordResults.length === 0) {
+        return [];
+    }
+    // 점수 병합을 위한 Map (key: text의 hash)
+    const scoreMap = new Map();
+    // 벡터 결과 처리 (코사인 유사도: 이미 0-1 범위)
+    for (const result of vectorResults) {
+        const key = makeKey(result.text, result.source);
+        scoreMap.set(key, {
+            text: result.text,
+            source: result.source,
+            score: result.score * vectorWeight,
+            vectorScore: result.score,
+        });
+    }
+    // 키워드 결과 정규화 및 병합
+    if (keywordResults.length > 0) {
+        const minBm25 = Math.min(...keywordResults.map(r => r.score));
+        const maxBm25 = Math.max(...keywordResults.map(r => r.score));
+        for (const result of keywordResults) {
+            const key = makeKey(result.text, result.source);
+            const normalizedScore = normalizeBm25Score(result.score, minBm25, maxBm25);
+            const existing = scoreMap.get(key);
+            if (existing) {
+                // 이미 벡터 결과에 있으면 점수 합산
+                existing.score += normalizedScore * keywordWeight;
+                existing.keywordScore = normalizedScore;
+            }
+            else {
+                // 새로운 결과
+                scoreMap.set(key, {
+                    text: result.text,
+                    source: result.source,
+                    score: normalizedScore * keywordWeight,
+                    keywordScore: normalizedScore,
+                });
+            }
+        }
+    }
+    // 점수 기준 정렬 후 상위 K개 반환
+    const results = Array.from(scoreMap.values())
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topK);
+    return results;
+}
+/**
+ * 벡터 검색만 수행합니다. (기존 동작 호환)
+ */
+export async function searchVector(query, topK = 5, minScore = 0.3) {
+    const queryEmbedding = await embed(query);
+    return vectorSearch(queryEmbedding, topK, minScore);
+}
+/**
+ * 키워드 검색만 수행합니다.
+ */
+export function searchByKeyword(query, limit = 10) {
+    return searchKeyword(query, limit);
+}
+/**
+ * 텍스트와 소스로 고유 키를 생성합니다.
+ */
+function makeKey(text, source) {
+    // 간단한 해시: 처음 100자 + 소스
+    return `${source}:${text.slice(0, 100)}`;
+}

package/dist/memory/index.js

@@ -1,4 +1,11 @@
 // Memory module exports
-export { embed, embedBatch, cosineSimilarity } from './embeddings.js';
-export { search, invalidateCache } from './vectorStore.js';
-export { indexFile, indexMainMemory, indexDailyMemories, reindexAll } from './indexer.js';
+// Embeddings
+export { embed, embedBatch, cosineSimilarity } from "./embeddings.js";
+// Vector store
+export { search, invalidateCache, loadAllMemoryChunks } from "./vectorStore.js";
+// FTS index
+export { indexText, indexTextBatch, searchKeyword, deleteBySource as deleteFtsBySource, deleteById as deleteFtsById, clearIndex as clearFtsIndex, getDocumentCount, closeDb as closeFtsDb, } from "./ftsIndex.js";
+// Hybrid search
+export { hybridSearch, searchVector, searchByKeyword, } from "./hybridSearch.js";
+// Indexer
+export { indexFile, indexMainMemory, indexDailyMemories, indexConversation, reindexAll, } from "./indexer.js";

package/dist/memory/indexer.js

@@ -1,39 +1,166 @@
 /**
  * 메모리 인덱서 모듈
- * 현재 구현은 vectorStore가 on-demand로 로드하므로 캐시 무효화만 수행
+ * 벡터 저장소와 FTS 인덱스 모두 업데이트합니다.
  */
-import { invalidateCache } from './vectorStore.js';
-// 단일 파일 인덱싱 (캐시 무효화)
-export async function indexFile(_filePath, _source) {
-    // vectorStore가 on-demand로 로드하므로 캐시만 무효화
-    invalidateCache();
-    return 1;
+import * as fs from "fs/promises";
+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";
+/**
+ * 텍스트를 청크로 분할합니다.
+ */
+function splitIntoChunks(text, source) {
+    const chunks = [];
+    let chunkIndex = 0;
+    // ## 헤더로 분할
+    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({
+                            id: `${source}:${chunkIndex++}`,
+                            text: currentChunk.trim(),
+                            source,
+                        });
+                    }
+                    currentChunk = line;
+                }
+                else {
+                    currentChunk += "\n" + line;
+                }
+            }
+            if (currentChunk.trim()) {
+                chunks.push({
+                    id: `${source}:${chunkIndex++}`,
+                    text: currentChunk.trim(),
+                    source,
+                });
+            }
+        }
+        else {
+            chunks.push({
+                id: `${source}:${chunkIndex++}`,
+                text: trimmed,
+                source,
+            });
+        }
+    }
+    return chunks;
 }
-// MEMORY.md 인덱싱
+/**
+ * 단일 파일 인덱싱 (캐시 무효화 + FTS 업데이트)
+ */
+export async function indexFile(filePath, source) {
+    try {
+        const content = await fs.readFile(filePath, "utf-8");
+        const chunks = splitIntoChunks(content, source);
+        // FTS 인덱스 업데이트
+        const ftsEntries = chunks.map(c => ({
+            id: c.id,
+            source: c.source,
+            text: c.text,
+        }));
+        indexTextBatch(ftsEntries);
+        // 벡터 캐시 무효화
+        invalidateCache();
+        return chunks.length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * MEMORY.md 인덱싱
+ */
 export async function indexMainMemory() {
-    invalidateCache();
-    return 1;
+    const memoryPath = getWorkspaceFilePath("MEMORY.md");
+    return indexFile(memoryPath, "MEMORY");
 }
-// 일일 메모리 파일들 인덱싱
-export async function indexDailyMemories(_days = 30) {
-    invalidateCache();
-    return 1;
+/**
+ * 일일 메모리 파일들 인덱싱
+ */
+export async function indexDailyMemories(days = 30) {
+    const memoryDir = getMemoryDirPath();
+    let totalChunks = 0;
+    try {
+        const files = await fs.readdir(memoryDir);
+        const mdFiles = files
+            .filter(f => f.endsWith(".md") && !f.startsWith("."))
+            .sort()
+            .reverse()
+            .slice(0, days);
+        for (const file of mdFiles) {
+            const filePath = path.join(memoryDir, file);
+            const source = file.replace(".md", "");
+            const count = await indexFile(filePath, source);
+            totalChunks += count;
+        }
+    }
+    catch {
+        // 디렉토리 없음 무시
+    }
+    return totalChunks;
+}
+/**
+ * 대화 기록 인덱싱 (JSONL 형식)
+ */
+export async function indexConversation(conversationId, messages) {
+    if (messages.length === 0)
+        return 0;
+    const ftsEntries = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!msg.content || msg.content.length < 10)
+            continue;
+        ftsEntries.push({
+            id: `conv:${conversationId}:${i}`,
+            source: `conversation:${conversationId}`,
+            text: `[${msg.role}] ${msg.content}`,
+        });
+    }
+    if (ftsEntries.length > 0) {
+        indexTextBatch(ftsEntries);
+    }
+    return ftsEntries.length;
 }
-// 전체 리인덱싱 (캐시 무효화 후 미리 로드)
+/**
+ * 전체 리인덱싱 (벡터 + FTS 모두)
+ */
 export async function reindexAll() {
-    console.log('[Indexer] Invalidating cache for reindex...');
+    console.log("[Indexer] Starting full reindex...");
+    // 1. FTS 인덱스 초기화
+    clearFtsIndex();
+    // 2. 벡터 캐시 무효화 및 로드
     invalidateCache();
-    // 캐시 무효화 후 즉시 로드하여 청크 수 반환
-    // search를 임시로 호출하여 로드 트리거 (빈 쿼리로)
-    const { loadAllMemoryChunks } = await import('./vectorStore.js');
     const chunks = await loadAllMemoryChunks();
-    // 소스별 집계
+    // 3. 모든 청크를 FTS에 인덱싱
+    const ftsEntries = chunks.map((chunk, idx) => ({
+        id: `${chunk.source}:${idx}`,
+        source: chunk.source,
+        text: chunk.text,
+    }));
+    if (ftsEntries.length > 0) {
+        indexTextBatch(ftsEntries);
+    }
+    // 4. 소스별 집계
     const sourceCounts = new Map();
     for (const chunk of chunks) {
         sourceCounts.set(chunk.source, (sourceCounts.get(chunk.source) || 0) + 1);
     }
+    const ftsCount = getDocumentCount();
+    console.log(`[Indexer] Indexed ${chunks.length} chunks to vector store, ${ftsCount} documents to FTS`);
     return {
         total: chunks.length,
-        sources: Array.from(sourceCounts.keys())
+        sources: Array.from(sourceCounts.keys()),
+        ftsCount,
     };
 }