companionbot 0.14.0 → 0.15.0

package/dist/agents/manager.js

@@ -8,6 +8,11 @@
  */
 import Anthropic from "@anthropic-ai/sdk";
 import { randomUUID } from "crypto";
+// ===== 제한 상수 =====
+const MAX_CONCURRENT_AGENTS = 10; // 전체 동시 Agent 최대 개수
+const MAX_AGENTS_PER_CHAT = 3; // chatId당 최대 동시 Agent 개수
+const CLEANUP_INTERVAL_MS = 30 * 60 * 1000; // 30분마다 cleanup
+const AGENT_TTL_MS = 30 * 60 * 1000; // Agent 보관 시간 (30분)
 // Agent 저장소
 const agents = new Map();
 // AbortController 저장소 (실행 중인 API 호출 취소용)
@@ -28,10 +33,50 @@ function getClient() {
 export function setAgentBot(bot) {
     botInstance = bot;
 }
+/**
+ * 가장 오래된 Agent 정리 (한도 초과 시)
+ */
+function evictOldestAgent() {
+    let oldest = null;
+    for (const agent of agents.values()) {
+        if (!oldest || agent.createdAt < oldest.createdAt) {
+            oldest = agent;
+        }
+    }
+    if (oldest) {
+        console.log(`[AgentManager] Evicting oldest agent: ${oldest.id}`);
+        // running이면 취소
+        if (oldest.status === "running") {
+            cancelAgent(oldest.id);
+        }
+        agents.delete(oldest.id);
+    }
+}
+/**
+ * chatId당 Agent 개수 확인
+ */
+function countAgentsForChat(chatId) {
+    let count = 0;
+    for (const agent of agents.values()) {
+        if (agent.chatId === chatId && agent.status === "running") {
+            count++;
+        }
+    }
+    return count;
+}
 /**
  * Sub-agent 생성 및 실행
  */
 export async function spawnAgent(task, chatId) {
+    // chatId당 제한 확인
+    const chatAgentCount = countAgentsForChat(chatId);
+    if (chatAgentCount >= MAX_AGENTS_PER_CHAT) {
+        throw new Error(`이 채팅에서 동시에 실행 가능한 Agent 수(${MAX_AGENTS_PER_CHAT}개)를 초과했습니다. 기존 Agent 완료를 기다려주세요.`);
+    }
+    // 전체 한도 확인 및 정리
+    while (agents.size >= MAX_CONCURRENT_AGENTS) {
+        evictOldestAgent();
+    }
     const id = randomUUID().slice(0, 8);
     const agent = {
         id,
@@ -41,6 +86,7 @@ export async function spawnAgent(task, chatId) {
         createdAt: new Date(),
     };
     agents.set(id, agent);
+    console.log(`[AgentManager] Agent created: ${id} (total: ${agents.size}/${MAX_CONCURRENT_AGENTS})`);
     // 비동기로 agent 실행 (await 하지 않음)
     runAgent(agent).catch((err) => {
         console.error(`[Agent ${id}] Error:`, err);
@@ -183,35 +229,47 @@ export function getAgent(agentId) {
     return agents.get(agentId);
 }
 /**
- * 오래된 agent 정리 (1시간 이상)
- * - 완료된 agent: completedAt 기준 1시간
- * - running 상태도 createdAt 기준 1시간 지나면 정리 (stuck 방지)
+ * 오래된 agent 정리 (30분 이상)
+ * - 완료된 agent: completedAt 기준 30분
+ * - running 상태도 createdAt 기준 30분 지나면 정리 (stuck 방지)
  */
 export function cleanupOldAgents() {
-    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+    const cutoff = Date.now() - AGENT_TTL_MS;
+    let cleaned = 0;
     for (const [id, agent] of agents.entries()) {
         // 완료된 agent: completedAt 기준
-        if (agent.completedAt && agent.completedAt.getTime() < oneHourAgo) {
+        if (agent.completedAt && agent.completedAt.getTime() < cutoff) {
             agents.delete(id);
+            cleaned++;
             continue;
         }
-        // running 상태도 1시간 지나면 정리 (stuck agent 방지)
-        if (agent.status === "running" && agent.createdAt.getTime() < oneHourAgo) {
-            console.log(`[Agent ${id}] Cleaning up stuck agent (running > 1h)`);
+        // running 상태도 TTL 지나면 정리 (stuck agent 방지)
+        if (agent.status === "running" && agent.createdAt.getTime() < cutoff) {
+            console.log(`[Agent ${id}] Cleaning up stuck agent (running > 30min)`);
+            // 실행 중인 API 호출 취소
+            const controller = abortControllers.get(id);
+            if (controller) {
+                controller.abort();
+                abortControllers.delete(id);
+            }
             agents.delete(id);
+            cleaned++;
         }
     }
+    if (cleaned > 0) {
+        console.log(`[AgentManager] Cleanup: removed ${cleaned} agents (remaining: ${agents.size})`);
+    }
 }
 // Cleanup interval 참조 저장
 let cleanupIntervalId = null;
 /**
- * 정기 cleanup 시작
+ * 정기 cleanup 시작 (30분 주기)
  */
 export function startCleanup() {
     if (cleanupIntervalId)
         return; // 이미 실행 중
-    cleanupIntervalId = setInterval(cleanupOldAgents, 10 * 60 * 1000);
-    console.log("[AgentManager] Cleanup interval started");
+    cleanupIntervalId = setInterval(cleanupOldAgents, CLEANUP_INTERVAL_MS);
+    console.log(`[AgentManager] Cleanup interval started (every ${CLEANUP_INTERVAL_MS / 60000}min)`);
 }
 /**
  * 정기 cleanup 중지

package/dist/telegram/bot.js

@@ -72,9 +72,11 @@ export function createBot(token) {
     // 명령어 목록 등록
     bot.api
         .setMyCommands([
+        { command: "help", description: "도움말 보기" },
+        { command: "model", description: "AI 모델 변경" },
         { command: "compact", description: "대화 정리하기" },
         { command: "memory", description: "최근 기억 보기" },
-        { command: "reminders", description: "알림 목록 보기" },
+        { command: "health", description: "봇 상태 확인" },
     ])
         .catch((err) => console.error("Failed to set commands:", err));
     // 핸들러 등록

package/dist/telegram/handlers/commands.js

@@ -60,6 +60,32 @@ import { setHeartbeatConfig, getHeartbeatConfig, disableHeartbeat, } from "../..
 import { getWorkspace, invalidateWorkspaceCache, buildSystemPrompt, extractName, } from "../utils/index.js";
 import { ensureDefaultCronJobs } from "../../cron/scheduler.js";
 export function registerCommands(bot) {
+    // /help 명령어 - 전체 기능 안내
+    bot.command("help", async (ctx) => {
+        await ctx.reply(`📖 도움말\n\n` +
+            `🎯 기본 기능\n` +
+            `/model - AI 모델 변경 (sonnet/opus/haiku)\n` +
+            `/compact - 대화 압축해서 토큰 절약\n` +
+            `/clear - 대화 초기화\n\n` +
+            `📌 기억/핀\n` +
+            `/memory - 최근 기억 보기\n` +
+            `/pin [내용] - 중요한 정보 핀하기\n` +
+            `/pins - 핀 목록 보기\n` +
+            `/context - 현재 맥락 상태\n\n` +
+            `⏰ 알림/일정\n` +
+            `/reminders - 알림 목록\n` +
+            `/briefing - 일일 브리핑 켜기/상태\n` +
+            `/calendar - 오늘 일정 보기\n\n` +
+            `⚙️ 설정\n` +
+            `/setup - 기능별 설정 관리\n` +
+            `/health - 봇 상태 확인\n` +
+            `/reset - 페르소나 초기화\n\n` +
+            `💡 자연어로도 말할 수 있어요:\n` +
+            `• "opus로 바꿔줘"\n` +
+            `• "10분 뒤에 알려줘"\n` +
+            `• "기억해: 나는 채식주의자야"\n` +
+            `• "내일 일정 뭐야?"`);
+    });
     // /start 명령어
     bot.command("start", async (ctx) => {
         const chatId = ctx.chat.id;
@@ -210,19 +236,19 @@ export function registerCommands(bot) {
             const modelList = Object.entries(MODELS)
                 .map(([id, m]) => `${id === currentModel ? "→" : "  "} /model ${id} - ${m.name}`)
                 .join("\n");
-            await ctx.reply(`Current model: ${MODELS[currentModel].name}\n\n` +
-                `Available models:\n${modelList}\n\n` +
-                `Tip: You can also ask me to change models in natural language!`);
+            await ctx.reply(`현재 모델: ${MODELS[currentModel].name}\n\n` +
+                `사용 가능한 모델:\n${modelList}\n\n` +
+                `팁: "모델 바꿔줘"처럼 자연어로도 바꿀 수 있어!`);
             return;
         }
         if (arg in MODELS) {
             const modelId = arg;
             setModel(chatId, modelId);
-            await ctx.reply(`Model changed to: ${MODELS[modelId].name}`);
+            await ctx.reply(`모델 변경됨: ${MODELS[modelId].name}`);
         }
         else {
-            await ctx.reply(`Unknown model: ${arg}\n\n` +
-                `Available: sonnet, opus, haiku`);
+            await ctx.reply(`모르는 모델이야: ${arg}\n\n` +
+                `사용 가능: sonnet, opus, haiku`);
         }
     });
     // /setup 명령어 - 추가 기능 설정 및 관리

package/dist/telegram/utils/prompt.js

@@ -2,10 +2,7 @@ import { MODELS } from "../../ai/claude.js";
 import { getWorkspacePath } from "../../workspace/index.js";
 import { getToolsDescription } from "../../tools/index.js";
 import { getWorkspace } from "./cache.js";
-import { embed } from "../../memory/embeddings.js";
-import { search } from "../../memory/vectorStore.js";
 import { buildContextForPrompt, getCurrentChatId } from "../../session/state.js";
-import { SEARCH_CONTEXT_LENGTH, PROMPT_MEMORY_SEARCH_LIMIT, PROMPT_MEMORY_MIN_SCORE, MEMORY_PREVIEW_LENGTH, } from "../../utils/constants.js";
 import * as os from "os";
 function getRuntimeInfo(modelId) {
     const model = MODELS[modelId];
@@ -49,32 +46,6 @@ export function extractName(identityContent) {
     }
     return null;
 }
-// ============== 메모리 검색 ==============
-function extractSearchContext(history) {
-    const recent = history.slice(-3);
-    return recent
-        .filter((m) => m.role === "user")
-        .map((m) => (typeof m.content === "string" ? m.content : ""))
-        .join(" ")
-        .slice(0, SEARCH_CONTEXT_LENGTH);
-}
-async function getRelevantMemories(history) {
-    try {
-        const context = extractSearchContext(history);
-        if (!context.trim())
-            return "";
-        const queryEmbedding = await embed(context);
-        const results = await search(queryEmbedding, PROMPT_MEMORY_SEARCH_LIMIT, PROMPT_MEMORY_MIN_SCORE);
-        if (results.length === 0)
-            return "";
-        return results
-            .map((r) => `- (${r.source}): ${r.text.slice(0, MEMORY_PREVIEW_LENGTH)}${r.text.length > MEMORY_PREVIEW_LENGTH ? "..." : ""}`)
-            .join("\n");
-    }
-    catch {
-        return "";
-    }
-}
 // ============== Core Identity 빌더 ==============
 function buildCoreIdentity(name) {
     const displayName = name || "AI companion";
@@ -98,11 +69,8 @@ You are NOT a generic assistant or chatbot. You are someone developing a real re
 }
 // ============== 메인 빌드 함수 ==============
 export async function buildSystemPrompt(modelId, history) {
-    // 🚀 병렬 실행: 워크스페이스 로드 + 관련 메모리 검색
-    const [workspace, relevantMemoriesResult] = await Promise.all([
-        getWorkspace(),
-        history && history.length > 0 ? getRelevantMemories(history) : Promise.resolve(""),
-    ]);
+    // 워크스페이스 로드 (메모리 검색은 memory_search 도구로 필요시에만)
+    const workspace = await getWorkspace();
     const runtime = getRuntimeInfo(modelId);
     const dateTime = getKoreanDateTime();
     const parts = [];
@@ -174,15 +142,7 @@ export async function buildSystemPrompt(modelId, history) {
         parts.push(workspace.recentDaily);
         parts.push("");
     }
-    // 관련 기억 (벡터 검색) - 위에서 병렬로 미리 가져옴
-    if (relevantMemoriesResult) {
-        parts.push("# Relevant Memories");
-        parts.push("");
-        parts.push("Related information from older records:");
-        parts.push("");
-        parts.push(relevantMemoriesResult);
-        parts.push("");
-    }
+    // 관련 기억: memory_search 도구로 필요시에만 검색 (자동 검색 제거됨)
     // 장기 기억
     if (workspace.memory) {
         parts.push("# Long-term Memory");

package/dist/tools/agent.js

@@ -0,0 +1,53 @@
+/**
+ * Sub-agent tools
+ */
+import { getCurrentChatId } from "../session/state.js";
+import { spawnAgent, listAgents, cancelAgent, } from "../agents/index.js";
+// spawn_agent
+export async function executeSpawnAgent(input) {
+    const chatId = getCurrentChatId();
+    if (!chatId) {
+        return "Error: No active chat session";
+    }
+    const task = input.task;
+    if (!task || task.trim().length === 0) {
+        return "Error: Task description is required";
+    }
+    const agentId = await spawnAgent(task, chatId);
+    return `Sub-agent spawned! 🤖\nID: ${agentId}\nTask: ${task.slice(0, 100)}${task.length > 100 ? "..." : ""}\n\nThe agent is working in the background. Results will be sent to this chat when complete.`;
+}
+// list_agents
+export function executeListAgents() {
+    const chatId = getCurrentChatId();
+    const agents = listAgents(chatId || undefined);
+    if (agents.length === 0) {
+        return "No sub-agents found.";
+    }
+    const lines = agents.map((a) => {
+        const status = {
+            running: "🔄 Running",
+            completed: "✅ Completed",
+            failed: "❌ Failed",
+            cancelled: "⏹️ Cancelled",
+        }[a.status];
+        const time = a.completedAt
+            ? `(${Math.round((a.completedAt.getTime() - a.createdAt.getTime()) / 1000)}s)`
+            : "";
+        return `${a.id}: ${status} ${time}\n   Task: ${a.task.slice(0, 60)}${a.task.length > 60 ? "..." : ""}`;
+    });
+    return `Sub-agents:\n${lines.join("\n\n")}`;
+}
+// cancel_agent
+export function executeCancelAgent(input) {
+    const agentId = input.agent_id;
+    if (!agentId) {
+        return "Error: Agent ID is required";
+    }
+    const success = cancelAgent(agentId);
+    if (success) {
+        return `Sub-agent ${agentId} cancelled.`;
+    }
+    else {
+        return `Could not cancel agent ${agentId}. It may not exist or already completed.`;
+    }
+}

package/dist/tools/file.js

@@ -0,0 +1,63 @@
+/**
+ * File operation tools
+ */
+import * as fs from "fs/promises";
+import * as path from "path";
+import { isPathAllowed } from "./pathCheck.js";
+// read_file
+export async function executeReadFile(input) {
+    const filePath = input.path;
+    if (!isPathAllowed(filePath)) {
+        return `Error: Access denied. Path not in allowed directories.`;
+    }
+    const content = await fs.readFile(filePath, "utf-8");
+    return content;
+}
+// write_file
+export async function executeWriteFile(input) {
+    const filePath = input.path;
+    const content = input.content;
+    if (!isPathAllowed(filePath)) {
+        return `Error: Access denied. Path not in allowed directories.`;
+    }
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, "utf-8");
+    return `File written successfully: ${filePath}`;
+}
+// edit_file
+export async function executeEditFile(input) {
+    const filePath = input.path;
+    const oldText = input.oldText;
+    const newText = input.newText;
+    if (!isPathAllowed(filePath)) {
+        return `Error: Access denied. Path not in allowed directories.`;
+    }
+    // 파일 읽기
+    let content;
+    try {
+        content = await fs.readFile(filePath, "utf-8");
+    }
+    catch (error) {
+        return `Error: Could not read file "${filePath}". ${error instanceof Error ? error.message : String(error)}`;
+    }
+    // oldText 찾기
+    const index = content.indexOf(oldText);
+    if (index === -1) {
+        return `Error: oldText not found in file. Make sure the text matches exactly (including whitespace).`;
+    }
+    // 첫 번째만 교체
+    const newContent = content.slice(0, index) + newText + content.slice(index + oldText.length);
+    // 저장
+    await fs.writeFile(filePath, newContent, "utf-8");
+    return `File edited successfully: ${filePath}`;
+}
+// list_directory
+export async function executeListDirectory(input) {
+    const dirPath = input.path;
+    if (!isPathAllowed(dirPath)) {
+        return `Error: Access denied. Path not in allowed directories.`;
+    }
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const list = entries.map((e) => `${e.isDirectory() ? "📁" : "📄"} ${e.name}`);
+    return list.join("\n");
+}