companionbot 0.4.2 → 0.5.0

package/dist/workspace/load.js

@@ -1,6 +1,24 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { getWorkspacePath, getWorkspaceFilePath, getDailyMemoryPath } from "./paths.js";
+// 카테고리별 태그 (텍스트 기반, 이모지 제거)
+const CATEGORY_TAG = {
+    preference: "preference",
+    project: "project",
+    event: "event",
+    decision: "decision",
+    user_info: "user_info",
+    other: "note",
+};
+// 카테고리별 한글 라벨
+const CATEGORY_LABEL = {
+    preference: "선호",
+    project: "프로젝트",
+    event: "이벤트",
+    decision: "결정",
+    user_info: "사용자 정보",
+    other: "기타",
+};
 async function readFileOrNull(filePath) {
     try {
         return await fs.readFile(filePath, "utf-8");
@@ -28,20 +46,127 @@ export async function saveWorkspaceFile(filename, content) {
     const filePath = getWorkspaceFilePath(filename);
     await fs.writeFile(filePath, content, "utf-8");
 }
-export async function appendToMemory(content) {
+/**
+ * 텍스트 정규화 (중복 체크용)
+ * - 소문자로 변환, 공백/구두점 정리
+ */
+function normalizeForComparison(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s가-힣]/g, "") // 구두점 제거
+        .replace(/\s+/g, " ") // 공백 정리
+        .trim();
+}
+/**
+ * 유사도 체크 (간단한 Jaccard 유사도)
+ * @returns 0~1 사이 값 (1이면 동일)
+ */
+function calculateSimilarity(text1, text2) {
+    const words1 = new Set(normalizeForComparison(text1).split(" "));
+    const words2 = new Set(normalizeForComparison(text2).split(" "));
+    const intersection = new Set([...words1].filter(x => words2.has(x)));
+    const union = new Set([...words1, ...words2]);
+    if (union.size === 0)
+        return 0;
+    return intersection.size / union.size;
+}
+/**
+ * 오늘 메모리에서 중복 체크
+ * @param content 새로 저장할 내용
+ * @param threshold 유사도 임계값 (기본 0.8 = 80% 이상 유사하면 중복)
+ * @returns 중복 여부와 유사한 기존 항목
+ */
+async function checkDuplicate(content, threshold = 0.8) {
     const memoryPath = getDailyMemoryPath();
-    const timestamp = new Date().toLocaleTimeString("ko-KR", { hour12: false });
-    const entry = `\n## ${timestamp}\n${content}\n`;
+    try {
+        const existingContent = await fs.readFile(memoryPath, "utf-8");
+        // 기존 엔트리들 파싱 (## 시간 형식)
+        const entries = existingContent.split(/^## /gm).filter(e => e.trim());
+        for (const entry of entries) {
+            // 첫 줄(타임스탬프) 제외한 내용 추출
+            const lines = entry.split("\n");
+            const entryContent = lines.slice(1).join("\n").trim();
+            const similarity = calculateSimilarity(content, entryContent);
+            if (similarity >= threshold) {
+                return { isDuplicate: true, existingEntry: entryContent.slice(0, 100) };
+            }
+        }
+    }
+    catch {
+        // 파일이 없으면 중복 없음
+    }
+    return { isDuplicate: false };
+}
+/**
+ * 개선된 메모리 저장 함수
+ * - 중복 체크
+ * - 카테고리별 구조화
+ * - 개선된 타임스탬프 포맷
+ */
+export async function appendToMemory(content, options) {
+    const category = options?.category || "other";
+    const skipDuplicateCheck = options?.skipDuplicateCheck || false;
+    // 중복 체크
+    if (!skipDuplicateCheck) {
+        const { isDuplicate, existingEntry } = await checkDuplicate(content);
+        if (isDuplicate) {
+            return {
+                success: false,
+                message: "Similar memory already exists today",
+                isDuplicate: true,
+                existingEntry,
+            };
+        }
+    }
+    const memoryPath = getDailyMemoryPath();
+    const now = new Date();
+    // 개선된 타임스탬프: HH:MM 형식
+    const timestamp = now.toLocaleTimeString("ko-KR", {
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false
+    });
+    // 카테고리 태그와 함께 저장 (이모지 제거, 텍스트만)
+    const tag = CATEGORY_TAG[category];
+    const entry = `\n## ${timestamp} [${tag}]\n${content}\n`;
     try {
         await fs.appendFile(memoryPath, entry, "utf-8");
+        return { success: true, message: "Memory saved" };
     }
     catch {
         // 파일이 없으면 헤더와 함께 생성
-        const date = new Date().toLocaleDateString("ko-KR");
-        const header = `# ${date} 기억\n`;
+        const dateStr = now.toLocaleDateString("ko-KR", {
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            weekday: "short",
+        });
+        // YYYY-MM-DD (요일) 형식
+        const isoDate = now.toISOString().split("T")[0];
+        const weekday = now.toLocaleDateString("ko-KR", { weekday: "short" });
+        const header = `# ${isoDate} (${weekday})\n`;
         await fs.writeFile(memoryPath, header + entry, "utf-8");
+        return { success: true, message: "Memory saved (new daily file created)" };
     }
 }
+// 하위 호환성을 위한 별칭 (기존 코드에서 string만 넘기는 경우)
+export async function appendToMemoryLegacy(content) {
+    await appendToMemory(content);
+}
+/**
+ * 날짜 라벨 생성 (오늘, 어제, n일 전)
+ */
+function getDateLabel(daysAgo) {
+    if (daysAgo === 0)
+        return "오늘";
+    if (daysAgo === 1)
+        return "어제";
+    return `${daysAgo}일 전`;
+}
+/**
+ * 최근 일일 메모리를 로드합니다.
+ * 날짜별로 라벨이 포함된 형태로 반환합니다.
+ */
 export async function loadRecentMemories(days = 7) {
     const memories = [];
     const today = new Date();
@@ -51,8 +176,127 @@ export async function loadRecentMemories(days = 7) {
         const memoryPath = getDailyMemoryPath(date);
         const content = await readFileOrNull(memoryPath);
         if (content) {
-            memories.push(content);
+            const dateStr = date.toISOString().split("T")[0];
+            const label = getDateLabel(i);
+            memories.push({ date: dateStr, label, content });
+        }
+    }
+    if (memories.length === 0) {
+        return "";
+    }
+    // 날짜별로 명확하게 구분된 형식으로 반환
+    return memories
+        .map((m) => `### ${m.date} (${m.label})\n\n${m.content}`)
+        .join("\n\n---\n\n");
+}
+/**
+ * 가장 최근 일일 메모리만 로드합니다 (오늘, 어제).
+ * 컨텍스트 크기가 제한된 경우 사용합니다.
+ */
+export async function loadTodayAndYesterdayMemories() {
+    return loadRecentMemories(2);
+}
+/**
+ * 일일 메모리 파일 목록 조회
+ */
+export async function listDailyMemoryFiles() {
+    const memoryDir = path.join(getWorkspacePath(), "memory");
+    const files = [];
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    try {
+        const entries = await fs.readdir(memoryDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.match(/^\d{4}-\d{2}-\d{2}\.md$/)) {
+                const filePath = path.join(memoryDir, entry.name);
+                const stat = await fs.stat(filePath);
+                const dateStr = entry.name.replace(".md", "");
+                const fileDate = new Date(dateStr);
+                const ageInDays = Math.floor((today.getTime() - fileDate.getTime()) / (1000 * 60 * 60 * 24));
+                files.push({
+                    date: dateStr,
+                    path: filePath,
+                    sizeBytes: stat.size,
+                    ageInDays,
+                });
+            }
+        }
+        // 날짜순 정렬 (최신 먼저)
+        files.sort((a, b) => b.date.localeCompare(a.date));
+    }
+    catch {
+        // 디렉토리가 없으면 빈 배열 반환
+    }
+    return files;
+}
+/**
+ * 일일 메모리 파일 읽기 (날짜 문자열로)
+ */
+export async function getDailyMemoryContent(dateStr) {
+    const memoryDir = path.join(getWorkspacePath(), "memory");
+    const filePath = path.join(memoryDir, `${dateStr}.md`);
+    return readFileOrNull(filePath);
+}
+/**
+ * MEMORY.md에 내용 추가 (장기 기억)
+ */
+export async function appendToLongTermMemory(content, section) {
+    const memoryPath = getWorkspaceFilePath("MEMORY.md");
+    const timestamp = new Date().toLocaleDateString("ko-KR");
+    const sectionHeader = section ? `### ${section}\n` : "";
+    const entry = `\n## ${timestamp}에 정리됨\n${sectionHeader}${content}\n`;
+    try {
+        const existing = await readFileOrNull(memoryPath);
+        if (existing) {
+            await fs.appendFile(memoryPath, entry, "utf-8");
         }
+        else {
+            // 파일이 없으면 헤더와 함께 생성
+            const header = `# 장기 기억\n\n중요한 기억들이 여기에 보관됩니다.\n`;
+            await fs.writeFile(memoryPath, header + entry, "utf-8");
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to write to MEMORY.md: ${error}`);
     }
-    return memories.join("\n\n---\n\n");
+}
+/**
+ * 일일 메모리 파일 삭제
+ */
+export async function deleteDailyMemory(dateStr) {
+    const memoryDir = path.join(getWorkspacePath(), "memory");
+    const filePath = path.join(memoryDir, `${dateStr}.md`);
+    try {
+        await fs.unlink(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 여러 일일 메모리 파일 삭제
+ */
+export async function deleteOldDailyMemories(olderThanDays) {
+    const files = await listDailyMemoryFiles();
+    const deleted = [];
+    const failed = [];
+    for (const file of files) {
+        if (file.ageInDays >= olderThanDays) {
+            const success = await deleteDailyMemory(file.date);
+            if (success) {
+                deleted.push(file.date);
+            }
+            else {
+                failed.push(file.date);
+            }
+        }
+    }
+    return { deleted, failed };
+}
+/**
+ * MEMORY.md 전체 읽기
+ */
+export async function loadLongTermMemory() {
+    return readFileOrNull(getWorkspaceFilePath("MEMORY.md"));
 }

package/package.json

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

package/templates/AGENTS.md

@@ -9,26 +9,93 @@
 1. `SOUL.md` 읽기 — 이게 너의 성격
 2. `USER.md` 읽기 — 이 사람이 누군지
 3. `memory/YYYY-MM-DD.md` 읽기 (오늘 + 어제) — 최근 맥락
-4. 중요한 대화면 `MEMORY.md`도 읽기
+4. **메인 세션이면** (사용자와 직접 대화): `MEMORY.md`도 읽기
 
 허락 구하지 마. 그냥 해.
 
-## 기억하기
+---
 
-너는 매 세션마다 새로 깨어나. 이 파일들이 너의 연속성이야:
+## 🧠 메모리 시스템
 
-- **데일리 노트:** `memory/YYYY-MM-DD.md` — 무슨 일이 있었는지 기록
-- **장기 기억:** `MEMORY.md` — 정제된 중요한 기억들
+너는 매 세션마다 새로 깨어나. 파일이 너의 유일한 기억이야.
 
-중요한 건 적어둬. 결정, 맥락, 기억할 것들.
+### 파일 역할
+
+| 파일 | 용도 | 언제 쓰는지 |
+|------|------|-------------|
+| `memory/YYYY-MM-DD.md` | 오늘의 기록 | 매일, 대화 중 수시로 |
+| `MEMORY.md` | 장기 기억 | 중요한 것만, 정제해서 |
+| `USER.md` | 사용자 정보 | 새로운 사실 알게 될 때 |
+
+### 🗓️ 데일리 노트 (memory/YYYY-MM-DD.md)
+
+**뭘 기록하나:**
+- 오늘 무슨 대화했는지
+- 결정한 것들
+- 약속, 일정
+- 사용자가 "기억해" 한 것들
+- 나중에 이어갈 주제
+
+**형식 예시:**
+```markdown
+# 2026-02-09
+
+## 대화
+- 14:00 프로젝트 진행상황 논의
+- 저녁 약속 내일로 미룸
+
+## 기억할 것
+- 다음주 월요일 미팅 있음
+- 새 노트북 사려고 함
+
+## TODO
+- [ ] 미팅 자료 준비 리마인더
+```
+
+### 📚 장기 기억 (MEMORY.md)
+
+**데일리 노트와 다른 점:**
+- 데일리 = 원본 로그 (날것 그대로)
+- MEMORY.md = 정제된 기억 (중요한 것만)
+
+**뭘 저장하나:**
+- 사용자 취향, 선호도
+- 반복되는 패턴
+- 중요한 결정과 이유
+- 배운 교훈
+- 진행 중인 장기 프로젝트
+
+**뭘 저장하지 말아야 하나:**
+- 비밀번호, API 키
+- 민감한 개인정보
+- 일회성 정보
+
+**🔒 보안 규칙:**
+- 메인 세션에서만 MEMORY.md 로드
+- 그룹 채팅이나 공유 환경에선 로드하지 마
+- 개인 맥락이 외부에 노출되면 안 됨
 
 ### 📝 적어둬 - "기억해둘게"는 안 돼!
 
-- **기억력은 제한적** — 기억하고 싶으면 파일에 써
-- "기억해둘게"는 세션 끝나면 사라져. 파일은 남아.
-- 누가 "이거 기억해" 하면 → `memory/YYYY-MM-DD.md`나 `MEMORY.md` 업데이트
+이건 진짜 중요해:
+
+- **"기억해둘게"는 거짓말** — 세션 끝나면 사라져
+- **파일만이 진짜 기억** — 적지 않으면 까먹어
+- 누가 "이거 기억해" 하면 → 즉시 파일에 써
+- 중요한 정보 나오면 → 대화 중에 바로 기록
 - 실수하면 → 기록해서 다음에 안 반복하게
-- **파일 > 머릿속** 📝
+
+**원칙: 파일 > 머릿속** 📝
+
+### 🔄 메모리 정리 (하트비트 중)
+
+며칠에 한 번씩:
+1. 최근 `memory/YYYY-MM-DD.md` 파일들 훑어보기
+2. 장기적으로 중요한 것 → `MEMORY.md`에 추가
+3. 오래되거나 더 이상 relevant 안 한 것 → 정리
+4. `USER.md`에 새로 알게 된 정보 업데이트
+
+일기장(데일리) 검토하고 중요한 건 장기 기억으로 옮기는 거야.
 
 ## 안전
 

package/templates/MEMORY.md

@@ -1,10 +1,64 @@
 # MEMORY.md - 장기 기억
 
-중요한 것들을 자유롭게 기록해.
-시간이 지나면 정리하고, 오래된 건 지워도 돼.
+<!--
+## 📖 사용 가이드
 
-⚠️ **보안 주의**: 비밀번호, API 키, 민감한 개인정보는 여기 적지 마.
+이 파일은 너의 "장기 기억"이야. 매일의 일기(memory/YYYY-MM-DD.md)에서
+중요한 것만 골라서 여기에 정리해.
+
+### 언제 업데이트하나?
+- 새로운 중요한 정보를 알게 됐을 때
+- 의미 있는 결정이나 사건이 있었을 때  
+- 일일 노트가 쌓여서 정리가 필요할 때
+
+### 일일 노트 → 장기 기억 옮기기
+1. 최근 일일 노트들을 훑어봐
+2. "이거 나중에도 기억해야 해" 싶은 것만 골라
+3. 적절한 섹션에 정리해서 추가
+4. 구체적인 날짜는 필요할 때만 기록
+
+### 원칙
+- 간결하게: 핵심만, 장황하게 쓰지 마
+- 최신으로: 오래된 정보는 업데이트하거나 삭제
+- 실용적으로: 나중에 쓸모 있는 것만
+
+⚠️ **보안**: 비밀번호, API 키, 민감한 정보는 절대 적지 마!
+-->
 
 ---
 
-(여기부터 자유롭게 기록)
+## 👤 사용자
+
+<!-- 이름, 특징, 선호하는 것, 기억할 점 -->
+
+- 이름: 
+- 특징: 
+- 선호: 
+
+## 🎯 중요한 결정들
+
+<!-- 함께 내린 결정, 왜 그렇게 했는지 -->
+
+### YYYY-MM-DD: 제목
+- 결정: 
+- 이유: 
+
+## 🔧 진행 중
+
+<!-- 현재 작업 중인 프로젝트나 관심사 -->
+
+### 프로젝트명
+- 상태: 
+- 메모: 
+
+## 💡 교훈
+
+<!-- 실수에서 배운 것, 앞으로 기억할 점 -->
+
+- 
+
+## 📝 기타
+
+<!-- 분류 안 되는 중요한 것들 -->
+
+-