companionbot 0.4.2 → 0.5.0

package/dist/telegram/utils/secrets.js

@@ -0,0 +1,64 @@
+/**
+ * API 키 및 시크릿 감지 유틸리티
+ * 사용자가 실수로 채팅에 API 키를 입력하는 것을 방지합니다.
+ */
+// API 키 패턴들 (정규식)
+const API_KEY_PATTERNS = [
+    // OpenAI
+    { name: "OpenAI", pattern: /sk-[a-zA-Z0-9]{20,}/ },
+    { name: "OpenAI Project", pattern: /sk-proj-[a-zA-Z0-9_-]{20,}/ },
+    // Anthropic
+    { name: "Anthropic", pattern: /sk-ant-[a-zA-Z0-9_-]{20,}/ },
+    { name: "Anthropic API", pattern: /anthropic-[a-zA-Z0-9_-]{20,}/ },
+    // Bearer tokens (일반)
+    { name: "Bearer Token", pattern: /Bearer\s+[a-zA-Z0-9_\-.]{20,}/ },
+    // GitHub
+    { name: "GitHub", pattern: /gh[pousr]_[a-zA-Z0-9]{20,}/ },
+    // Slack
+    { name: "Slack", pattern: /xox[bpras]-[a-zA-Z0-9\-]{20,}/ },
+    // Google
+    { name: "Google API", pattern: /AIza[a-zA-Z0-9_-]{35}/ },
+    // AWS
+    { name: "AWS Access Key", pattern: /AKIA[A-Z0-9]{16}/ },
+    { name: "AWS Secret", pattern: /[a-zA-Z0-9/+=]{40}(?=\s|$)/ },
+    // Telegram Bot Token
+    { name: "Telegram Bot", pattern: /\d{8,10}:[a-zA-Z0-9_-]{35}/ },
+    // Discord
+    { name: "Discord", pattern: /[MN][a-zA-Z0-9]{23,}\.[a-zA-Z0-9_-]{6}\.[a-zA-Z0-9_-]{27,}/ },
+    // Stripe
+    { name: "Stripe", pattern: /sk_live_[a-zA-Z0-9]{20,}/ },
+    { name: "Stripe Test", pattern: /sk_test_[a-zA-Z0-9]{20,}/ },
+    // Twilio
+    { name: "Twilio", pattern: /SK[a-f0-9]{32}/ },
+    // SendGrid
+    { name: "SendGrid", pattern: /SG\.[a-zA-Z0-9_-]{22}\.[a-zA-Z0-9_-]{43}/ },
+    // Private keys
+    { name: "Private Key", pattern: /-----BEGIN\s+(RSA\s+)?PRIVATE\s+KEY-----/ },
+    // Generic API key patterns (높은 엔트로피 문자열)
+    { name: "API Key", pattern: /(?:api[_-]?key|apikey|secret[_-]?key|access[_-]?token)\s*[:=]\s*['"]?[a-zA-Z0-9_\-]{20,}['"]?/i },
+];
+/**
+ * 메시지에서 API 키나 시크릿을 감지합니다.
+ * @param message 검사할 메시지
+ * @returns 감지 결과
+ */
+export function detectSecrets(message) {
+    const detectedTypes = [];
+    for (const { name, pattern } of API_KEY_PATTERNS) {
+        if (pattern.test(message)) {
+            detectedTypes.push(name);
+        }
+    }
+    return {
+        detected: detectedTypes.length > 0,
+        types: [...new Set(detectedTypes)], // 중복 제거
+    };
+}
+/**
+ * 메시지에 API 키가 포함되어 있는지 빠르게 확인합니다.
+ * @param message 검사할 메시지
+ * @returns API 키 포함 여부
+ */
+export function containsSecret(message) {
+    return API_KEY_PATTERNS.some(({ pattern }) => pattern.test(message));
+}

package/dist/tools/index.js

@@ -7,7 +7,9 @@ import { randomUUID } from "crypto";
 import { MODELS } from "../ai/claude.js";
 import { getCurrentChatId, setModel, getModel } from "../session/state.js";
 // Note: getCurrentChatId uses AsyncLocalStorage - must be called within runWithChatId context
-import { getWorkspacePath, saveWorkspaceFile, appendToMemory, deleteBootstrap, } from "../workspace/index.js";
+import { getWorkspacePath, saveWorkspaceFile, appendToMemory, deleteBootstrap, 
+// 메모리 정리 도구용
+listDailyMemoryFiles, getDailyMemoryContent, appendToLongTermMemory, deleteOldDailyMemories, loadLongTermMemory, } from "../workspace/index.js";
 import { getSecret } from "../config/secrets.js";
 import { createReminder, deleteReminder, getReminders, parseTimeExpression, } from "../reminders/index.js";
 import { isCalendarConfigured, getEvents, addEvent, deleteEvent, formatEvent, parseDateExpression, } from "../calendar/index.js";
@@ -16,6 +18,7 @@ import { setBriefingConfig, getBriefingConfig, disableBriefing, sendBriefingNow,
 import { spawnAgent, listAgents, cancelAgent, } from "../agents/index.js";
 import { addCronJob, listCronJobs, removeCronJob, setCronJobEnabled, runCronJobNow, parseScheduleExpression, } from "../cron/index.js";
 import * as cheerio from "cheerio";
+import * as dns from "dns/promises";
 const execAsync = promisify(exec);
 // 메모리에 세션 저장
 const sessions = new Map();
@@ -49,13 +52,32 @@ function appendOutput(session, data) {
 }
 // 홈 디렉토리
 const home = process.env.HOME || "";
-// 허용된 디렉토리 (보안을 위해 제한)
+// 허용된 디렉토리 설정
+// - COMPANIONBOT_FULL_ACCESS=true: 홈 디렉토리 전체 접근 (위험한 파일 패턴은 여전히 차단)
+// - COMPANIONBOT_ALLOWED_PATHS: 콜론(:)으로 구분된 추가 경로 (예: /tmp:/var/data)
+// - 기본값: ~/Documents, ~/projects, 워크스페이스
 function getAllowedPaths() {
-    return [
+    // 전체 접근 모드
+    if (process.env.COMPANIONBOT_FULL_ACCESS === "true") {
+        return [home];
+    }
+    // 기본 경로
+    const paths = [
         path.join(home, "Documents"),
         path.join(home, "projects"),
-        getWorkspacePath(), // 워크스페이스 경로 추가
+        getWorkspacePath(),
     ];
+    // 환경변수로 추가 경로 설정
+    const extraPaths = process.env.COMPANIONBOT_ALLOWED_PATHS;
+    if (extraPaths) {
+        const extras = extraPaths.split(":").filter(p => p.trim());
+        for (const p of extras) {
+            // ~ 확장
+            const expanded = p.startsWith("~") ? path.join(home, p.slice(1)) : p;
+            paths.push(expanded);
+        }
+    }
+    return paths;
 }
 // 위험한 파일 패턴
 // SSRF 방지: 사설 IP 체크
@@ -330,18 +352,34 @@ Guidelines:
     },
     {
         name: "save_memory",
-        description: "Save important information about the user or conversation to long-term memory. Use this when you learn something new about the user that should be remembered.",
+        description: `Save important information to daily memory. Use when you learn something about the user.
+
+Features:
+- Duplicate check: Won't save if similar content exists today (80% similarity threshold)
+- Categories help organize memories for later retrieval
+
+Guidelines:
+- Use "preference" for likes/dislikes (음식, 음악, 스타일 등)
+- Use "project" for work/projects (코드, 진행상황 등)  
+- Use "event" for dates/events (생일, 약속, 기념일)
+- Use "decision" for decisions/agreements (결정, 약속)
+- Use "user_info" for personal info (이름, 직업 등)
+- Use force_save=true to bypass duplicate check if needed`,
         input_schema: {
             type: "object",
             properties: {
                 content: {
                     type: "string",
-                    description: "The information to remember",
+                    description: "The information to remember. Be concise but specific.",
                 },
                 category: {
                     type: "string",
-                    enum: ["user_info", "preference", "event", "project", "other"],
-                    description: "Category of the memory",
+                    enum: ["preference", "project", "event", "decision", "user_info", "other"],
+                    description: "Category of the memory (affects emoji and organization)",
+                },
+                force_save: {
+                    type: "boolean",
+                    description: "Skip duplicate check and save anyway (default: false)",
                 },
             },
             required: ["content"],
@@ -763,6 +801,103 @@ Examples:
             required: ["id"],
         },
     },
+    // ============== 메모리 정리 도구 ==============
+    {
+        name: "list_daily_memories",
+        description: `List all daily memory files with their dates and sizes. Use to see what memories exist before organizing or cleaning.
+
+Use this when:
+- User asks what memories exist
+- Before organizing memories to see available files
+- Before cleaning old memories to check what will be affected`,
+        input_schema: {
+            type: "object",
+            properties: {
+                max_age_days: {
+                    type: "number",
+                    description: "Only show files older than this many days (optional)",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "get_daily_memory",
+        description: "Get the content of a specific daily memory file by date.",
+        input_schema: {
+            type: "object",
+            properties: {
+                date: {
+                    type: "string",
+                    description: "Date in YYYY-MM-DD format (e.g., '2025-02-07')",
+                },
+            },
+            required: ["date"],
+        },
+    },
+    {
+        name: "organize_memory",
+        description: `Move important content from daily memory files to long-term MEMORY.md.
+
+Use during heartbeats or when user asks to organize memories:
+1. Review recent daily files (call list_daily_memories first)
+2. Identify significant events, decisions, lessons, or insights
+3. Use this tool to save them to MEMORY.md with a section name
+4. Optionally clear old daily files with clear_old_memory
+
+Example flow:
+1. list_daily_memories → see available files
+2. get_daily_memory date="2025-02-05" → review content
+3. organize_memory content="사용자는 오후에 집중력이 높다고 함" section="선호도"`,
+        input_schema: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "The important content to save to long-term memory",
+                },
+                section: {
+                    type: "string",
+                    description: "Optional section/category name (e.g., '선호도', '프로젝트', '결정사항')",
+                },
+            },
+            required: ["content"],
+        },
+    },
+    {
+        name: "clear_old_memory",
+        description: `Delete old daily memory files. Use after organizing to clean up storage.
+
+Safety: Will not delete today's or yesterday's files by default.
+Recommendation: Set older_than_days to at least 7 to keep a week of context.
+
+Examples:
+- "30일 지난 메모리 정리해줘" → older_than_days: 30
+- "2주 이상 된 것만 삭제해" → older_than_days: 14`,
+        input_schema: {
+            type: "object",
+            properties: {
+                older_than_days: {
+                    type: "number",
+                    description: "Delete files older than this many days (minimum: 2, default: 30)",
+                },
+                dry_run: {
+                    type: "boolean",
+                    description: "If true, only show what would be deleted without actually deleting (default: true)",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "get_long_term_memory",
+        description: "Read the current contents of MEMORY.md (long-term memory).",
+        input_schema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
 ];
 // Tool 실행 함수
 export async function executeTool(name, input) {
@@ -833,12 +968,50 @@ export async function executeTool(name, input) {
                     "which", "env", "printenv"
                 ];
                 // 명령어 체이닝/치환/리디렉션 차단 (;, &&, ||, |, `, $(), ${}, 개행, >, <)
+                // Shell injection 방지: shell: false 사용하더라도 이중 방어
                 if (/[;&|`\n\r]|\$\(|\$\{|>>|>|</.test(command)) {
                     return `Error: Command chaining, substitution, and redirection not allowed.`;
                 }
-                // 첫 번째 명령어 추출
-                const parts = command.trim().split(/\s+/);
+                // 인자 파싱 (쉘을 거치지 않으므로 직접 파싱)
+                // 간단한 공백 분리 (따옴표 처리 포함)
+                const parseArgs = (cmd) => {
+                    const args = [];
+                    let current = "";
+                    let inQuote = null;
+                    for (let i = 0; i < cmd.length; i++) {
+                        const char = cmd[i];
+                        if (inQuote) {
+                            if (char === inQuote) {
+                                inQuote = null;
+                            }
+                            else {
+                                current += char;
+                            }
+                        }
+                        else if (char === '"' || char === "'") {
+                            inQuote = char;
+                        }
+                        else if (char === " " || char === "\t") {
+                            if (current) {
+                                args.push(current);
+                                current = "";
+                            }
+                        }
+                        else {
+                            current += char;
+                        }
+                    }
+                    if (current) {
+                        args.push(current);
+                    }
+                    return args;
+                };
+                const parts = parseArgs(command.trim());
+                if (parts.length === 0) {
+                    return `Error: Empty command.`;
+                }
                 const cmd = parts[0];
+                const args = parts.slice(1);
                 if (!ALLOWED_COMMANDS.includes(cmd)) {
                     return `Error: Command '${cmd}' not in allowed list. Allowed: ${ALLOWED_COMMANDS.join(", ")}`;
                 }
@@ -847,6 +1020,13 @@ export async function executeTool(name, input) {
                 if (dangerousArgs.some(arg => parts.includes(arg))) {
                     return `Error: Dangerous argument detected.`;
                 }
+                // 인자에 쉘 메타문자가 있으면 차단 (이중 방어)
+                const shellMetaChars = /[;&|`$\\<>(){}[\]!#*?~]/;
+                for (const arg of args) {
+                    if (shellMetaChars.test(arg)) {
+                        return `Error: Invalid characters in argument: ${arg}`;
+                    }
+                }
                 // 환경 변수는 필요한 것만 화이트리스트로 전달 (민감 정보 노출 방지)
                 const safeEnv = {
                     PATH: process.env.PATH || "",
@@ -855,14 +1035,16 @@ export async function executeTool(name, input) {
                     LANG: process.env.LANG || "en_US.UTF-8",
                     TERM: process.env.TERM || "xterm",
                 };
-                // Background 실행
+                // Background 실행 - shell: false (spawn 직접 사용)
                 if (background) {
                     const sessionId = randomUUID().slice(0, 8);
-                    const child = spawn("sh", ["-c", command], {
+                    // shell: false - 쉘을 거치지 않고 직접 실행
+                    const child = spawn(cmd, args, {
                         cwd,
                         env: safeEnv,
                         detached: true,
                         stdio: ["ignore", "pipe", "pipe"],
+                        shell: false, // 명시적으로 shell 비활성화
                     });
                     const session = {
                         id: sessionId,
@@ -902,14 +1084,41 @@ CWD: ${cwd}
 
 Use list_sessions to see all sessions, get_session_log to view output, kill_session to terminate.`;
                 }
-                // Foreground 실행 (기존 방식)
+                // Foreground 실행 - spawn with shell: false
                 try {
-                    const { stdout, stderr } = await execAsync(command, {
-                        cwd,
-                        timeout,
-                        env: safeEnv,
+                    const result = await new Promise((resolve, reject) => {
+                        const child = spawn(cmd, args, {
+                            cwd,
+                            env: safeEnv,
+                            shell: false, // shell 비활성화
+                        });
+                        let stdout = "";
+                        let stderr = "";
+                        child.stdout?.on("data", (data) => {
+                            stdout += data.toString();
+                        });
+                        child.stderr?.on("data", (data) => {
+                            stderr += data.toString();
+                        });
+                        const timeoutId = setTimeout(() => {
+                            child.kill("SIGTERM");
+                            reject(new Error(`Command timed out after ${timeout / 1000}s`));
+                        }, timeout);
+                        child.on("close", (code) => {
+                            clearTimeout(timeoutId);
+                            if (code === 0) {
+                                resolve({ stdout, stderr });
+                            }
+                            else {
+                                reject(new Error(`Command failed with exit code ${code}: ${stderr || stdout}`));
+                            }
+                        });
+                        child.on("error", (err) => {
+                            clearTimeout(timeoutId);
+                            reject(err);
+                        });
                     });
-                    return stdout || stderr || "Command executed (no output)";
+                    return result.stdout || result.stderr || "Command executed (no output)";
                 }
                 catch (error) {
                     return `Error: ${error instanceof Error ? error.message : String(error)}`;
@@ -1014,8 +1223,15 @@ ${"─".repeat(40)}`;
             case "save_memory": {
                 const content = input.content;
                 const category = input.category || "other";
-                await appendToMemory(`[${category}] ${content}`);
-                return `Memory saved: ${content.slice(0, 50)}...`;
+                const forceSave = input.force_save || false;
+                const result = await appendToMemory(content, {
+                    category: category,
+                    skipDuplicateCheck: forceSave,
+                });
+                if (!result.success && result.isDuplicate) {
+                    return `Memory not saved (duplicate detected). Similar entry: "${result.existingEntry}..."`;
+                }
+                return `Memory saved [${category}]: ${content.slice(0, 50)}${content.length > 50 ? "..." : ""}`;
             }
             case "save_persona": {
                 const identity = input.identity;
@@ -1356,9 +1572,11 @@ ${"─".repeat(40)}`;
                 if (!url.startsWith("http://") && !url.startsWith("https://")) {
                     return "Error: URL must start with http:// or https://";
                 }
-                // SSRF 방지: 사설 IP 차단
+                // SSRF 방지: 사설 IP 차단 + DNS rebinding 방지
+                let parsedUrl;
                 try {
-                    const parsedUrl = new URL(url);
+                    parsedUrl = new URL(url);
+                    // 1차 검증: hostname이 직접 IP인 경우
                     if (isPrivateIP(parsedUrl.hostname)) {
                         return "Error: Access to private/internal addresses is not allowed.";
                     }
@@ -1366,12 +1584,52 @@ ${"─".repeat(40)}`;
                 catch {
                     return "Error: Invalid URL format.";
                 }
+                // DNS rebinding 방지: 실제 IP 주소를 먼저 resolve하고 검증
+                try {
+                    // IP 주소가 아닌 hostname만 DNS lookup 수행
+                    const isIPAddress = /^[\d.]+$/.test(parsedUrl.hostname) || parsedUrl.hostname.includes(":");
+                    if (!isIPAddress) {
+                        const addresses = await dns.lookup(parsedUrl.hostname, { all: true });
+                        for (const addr of addresses) {
+                            if (isPrivateIP(addr.address)) {
+                                return `Error: DNS resolves to private IP (${addr.address}). Access denied.`;
+                            }
+                        }
+                    }
+                }
+                catch (dnsError) {
+                    // DNS lookup 실패 - 도메인이 존재하지 않거나 resolve 불가
+                    return `Error: Could not resolve hostname: ${parsedUrl.hostname}`;
+                }
                 try {
+                    // fetch 시 redirect 제한 (redirect를 통한 SSRF 방지)
+                    const controller = new AbortController();
+                    const timeoutId = setTimeout(() => controller.abort(), 30000);
                     const response = await fetch(url, {
                         headers: {
                             "User-Agent": "Mozilla/5.0 (compatible; CompanionBot/1.0)",
                         },
+                        redirect: "manual", // redirect 직접 처리
+                        signal: controller.signal,
                     });
+                    clearTimeout(timeoutId);
+                    // Redirect 처리: 새 URL도 검증
+                    if (response.status >= 300 && response.status < 400) {
+                        const redirectUrl = response.headers.get("location");
+                        if (redirectUrl) {
+                            try {
+                                const redirectParsed = new URL(redirectUrl, url);
+                                if (isPrivateIP(redirectParsed.hostname)) {
+                                    return "Error: Redirect to private/internal address blocked.";
+                                }
+                                // 재귀 호출 대신 단일 redirect만 허용하고 에러 반환
+                                return `Error: URL redirects to ${redirectUrl}. Please use the final URL directly.`;
+                            }
+                            catch {
+                                return "Error: Invalid redirect URL.";
+                            }
+                        }
+                    }
                     if (!response.ok) {
                         return `Error: Failed to fetch URL (${response.status}: ${response.statusText})`;
                     }
@@ -1535,6 +1793,96 @@ Next run: ${nextRunStr}`;
                     return `Error: Cron job ${id} not found.`;
                 }
             }
+            // ============== 메모리 정리 도구 ==============
+            case "list_daily_memories": {
+                const maxAgeDays = input.max_age_days;
+                const files = await listDailyMemoryFiles();
+                if (files.length === 0) {
+                    return "No daily memory files found.";
+                }
+                // 필터링 (maxAgeDays가 지정된 경우)
+                const filtered = maxAgeDays !== undefined
+                    ? files.filter(f => f.ageInDays >= maxAgeDays)
+                    : files;
+                if (filtered.length === 0) {
+                    return `No memory files older than ${maxAgeDays} days.`;
+                }
+                const lines = filtered.map(f => {
+                    const sizeKb = (f.sizeBytes / 1024).toFixed(1);
+                    const ageLabel = f.ageInDays === 0 ? "오늘"
+                        : f.ageInDays === 1 ? "어제"
+                            : `${f.ageInDays}일 전`;
+                    return `📅 ${f.date} (${ageLabel}) - ${sizeKb}KB`;
+                });
+                const totalSize = filtered.reduce((sum, f) => sum + f.sizeBytes, 0);
+                const totalKb = (totalSize / 1024).toFixed(1);
+                return `Daily memory files (${filtered.length} files, ${totalKb}KB total):\n\n${lines.join("\n")}`;
+            }
+            case "get_daily_memory": {
+                const date = input.date;
+                if (!date || !/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+                    return "Error: Date must be in YYYY-MM-DD format (e.g., '2025-02-07')";
+                }
+                const content = await getDailyMemoryContent(date);
+                if (!content) {
+                    return `No memory file found for ${date}.`;
+                }
+                return `📅 ${date} 메모리:\n\n${content}`;
+            }
+            case "organize_memory": {
+                const content = input.content;
+                const section = input.section;
+                if (!content || content.trim().length === 0) {
+                    return "Error: Content is required for organizing memory";
+                }
+                try {
+                    await appendToLongTermMemory(content.trim(), section);
+                    const sectionNote = section ? ` (섹션: ${section})` : "";
+                    return `✅ Long-term memory updated${sectionNote}.\n\nAdded:\n${content.slice(0, 200)}${content.length > 200 ? "..." : ""}`;
+                }
+                catch (error) {
+                    return `Error saving to long-term memory: ${error instanceof Error ? error.message : String(error)}`;
+                }
+            }
+            case "clear_old_memory": {
+                const olderThanDays = Math.max(2, input.older_than_days || 30);
+                const dryRun = input.dry_run !== false; // default to true for safety
+                const files = await listDailyMemoryFiles();
+                const toDelete = files.filter(f => f.ageInDays >= olderThanDays);
+                if (toDelete.length === 0) {
+                    return `No memory files older than ${olderThanDays} days to delete.`;
+                }
+                const totalSize = toDelete.reduce((sum, f) => sum + f.sizeBytes, 0);
+                const totalKb = (totalSize / 1024).toFixed(1);
+                if (dryRun) {
+                    const fileList = toDelete.slice(0, 10).map(f => `  - ${f.date}`).join("\n");
+                    const moreNote = toDelete.length > 10 ? `\n  ... and ${toDelete.length - 10} more` : "";
+                    return `🔍 DRY RUN - Would delete ${toDelete.length} files (${totalKb}KB):\n${fileList}${moreNote}\n\nSet dry_run=false to actually delete.`;
+                }
+                // 실제 삭제
+                const result = await deleteOldDailyMemories(olderThanDays);
+                if (result.deleted.length === 0) {
+                    return "No files were deleted.";
+                }
+                const deletedList = result.deleted.slice(0, 5).join(", ");
+                const moreNote = result.deleted.length > 5 ? ` and ${result.deleted.length - 5} more` : "";
+                let response = `🗑️ Deleted ${result.deleted.length} memory files: ${deletedList}${moreNote}`;
+                if (result.failed.length > 0) {
+                    response += `\n⚠️ Failed to delete: ${result.failed.join(", ")}`;
+                }
+                return response;
+            }
+            case "get_long_term_memory": {
+                const content = await loadLongTermMemory();
+                if (!content) {
+                    return "MEMORY.md does not exist yet. Use organize_memory to start building long-term memory.";
+                }
+                // 크기 제한 (너무 크면 요약 권장)
+                if (content.length > 10000) {
+                    return `📚 MEMORY.md (${(content.length / 1024).toFixed(1)}KB - showing first 10KB):\n\n${content.slice(0, 10000)}\n\n... (truncated, full file is ${content.length} chars)`;
+                }
+                return `📚 MEMORY.md:\n\n${content}`;
+            }
             default:
                 return `Error: Unknown tool: ${name}`;
         }
@@ -1613,5 +1961,17 @@ export function getToolsDescription(modelId) {
 - toggle_cron: cron job 활성화/비활성화 (id, enabled)
 - run_cron: cron job 즉시 실행 (id) - 테스트/수동 트리거용
 
+## 메모리 정리 (Long-term Memory Management)
+- list_daily_memories: 일일 메모리 파일 목록 조회
+  - max_age_days: N일 이상된 것만 필터
+- get_daily_memory: 특정 날짜의 메모리 읽기 (date: "YYYY-MM-DD")
+- organize_memory: 중요한 내용을 MEMORY.md로 이동
+  - content: 저장할 내용
+  - section: 섹션명 (선택)
+- clear_old_memory: 오래된 일일 메모리 정리
+  - older_than_days: N일 이상 (기본 30일, 최소 2일)
+  - dry_run: true면 미리보기만 (기본 true)
+- get_long_term_memory: MEMORY.md 내용 읽기
+
 허용된 경로: ${path.join(home, "Documents")}, ${path.join(home, "projects")}, 워크스페이스`;
 }

package/dist/workspace/index.js

@@ -3,4 +3,6 @@ export { getWorkspacePath, getWorkspaceFilePath, getMemoryDirPath, getDailyMemor
 // 초기화 함수
 export { isWorkspaceInitialized, initWorkspace, hasBootstrap, deleteBootstrap, } from "./init.js";
 // 로드/저장 함수
-export { loadWorkspace, loadBootstrap, saveWorkspaceFile, appendToMemory, loadRecentMemories, } from "./load.js";
+export { loadWorkspace, loadBootstrap, saveWorkspaceFile, appendToMemory, loadRecentMemories, loadTodayAndYesterdayMemories, 
+// 메모리 정리 도구용
+listDailyMemoryFiles, getDailyMemoryContent, appendToLongTermMemory, deleteDailyMemory, deleteOldDailyMemories, loadLongTermMemory, } from "./load.js";