companionbot 0.13.1 → 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/ai/claude.js

@@ -23,7 +23,7 @@ function getClient() {
     }
     return anthropic;
 }
-// Thinking 레벨별 설정 (비율 및 최대값)
+// Thinking 레벨별 설정
 export const THINKING_CONFIGS = {
     off: { ratio: 0, maxBudget: 0 },
     low: { ratio: 0.3, maxBudget: 5000 },
@@ -36,7 +36,7 @@ export const MODELS = {
         id: "claude-haiku-3-5-20241022",
         name: "Claude Haiku 3.5",
         contextWindow: 200000,
-        supportsThinking: false, // Haiku는 thinking 미지원
+        supportsThinking: false,
     },
     sonnet: {
         id: "claude-sonnet-4-20250514",
@@ -51,59 +51,47 @@ export const MODELS = {
         supportsThinking: true,
     },
 };
-// 동적 토큰 계산을 위한 설정
-const MIN_OUTPUT_TOKENS = 4096; // 최소 출력 토큰
-const OUTPUT_BUFFER_RATIO = 0.3; // 컨텍스트의 30%를 출력용으로 예약
+// 동적 토큰 계산 설정
+const MIN_OUTPUT_TOKENS = 4096;
+const OUTPUT_BUFFER_RATIO = 0.3;
 /**
  * 동적으로 max_tokens와 thinking budget 계산
- *
- * @param modelId 모델 ID
- * @param thinkingLevel thinking 레벨
- * @param inputTokens 현재 입력 토큰 수 (시스템 프롬프트 + 히스토리)
- * @returns { maxTokens, thinkingBudget }
  */
 export function calculateTokenBudgets(modelId, thinkingLevel, inputTokens) {
     const model = MODELS[modelId];
     const thinkingConfig = THINKING_CONFIGS[thinkingLevel];
-    // Thinking 미지원 모델이거나 off인 경우
     if (!model.supportsThinking || thinkingLevel === "off") {
-        // 간단히 고정 max_tokens 사용
         return { maxTokens: 8192, thinkingBudget: 0 };
     }
-    // 사용 가능한 출력 토큰 계산
-    // 컨텍스트 윈도우 - 입력 토큰 = 출력 가능 토큰
     const availableOutputTokens = model.contextWindow - inputTokens;
-    // 최소 출력 토큰 보장
     const maxTokens = Math.max(MIN_OUTPUT_TOKENS, Math.floor(availableOutputTokens * OUTPUT_BUFFER_RATIO));
-    // thinking budget 계산: min(레벨별 최대값, max_tokens * 비율)
-    // API 조건: max_tokens > budget_tokens 이므로 max_tokens - 1024 로 상한 설정
     const calculatedBudget = Math.floor(maxTokens * thinkingConfig.ratio);
-    const thinkingBudget = Math.min(thinkingConfig.maxBudget, calculatedBudget, maxTokens - 1024 // max_tokens > budget_tokens 조건 충족
-    );
-    // budget이 1024 미만이면 thinking 비활성화 (의미 없음)
+    const thinkingBudget = Math.min(thinkingConfig.maxBudget, calculatedBudget, maxTokens - 1024);
     if (thinkingBudget < 1024) {
         return { maxTokens, thinkingBudget: 0 };
     }
     return { maxTokens, thinkingBudget };
 }
-export async function chat(messages, systemPrompt, modelId = "sonnet", _thinkingLevel // 사용 안 함 (non-streaming에서 에러 발생)
-) {
+/**
+ * Claude API 호출 (스트리밍 내부 사용, thinking 지원)
+ * - 스트리밍으로 호출하되 최종 응답만 반환 (사용자에게 중간 메시지 안 보냄)
+ * - thinking 활성화 가능
+ * - 도구 사용 시에는 non-streaming으로 폴백 (thinking off)
+ */
+export async function chat(messages, systemPrompt, modelId = "sonnet", thinkingLevel = "medium") {
     const client = getClient();
     const modelConfig = MODELS[modelId];
     const toolsUsed = [];
-    // 메시지를 API 형식으로 변환
     const apiMessages = messages.map((m) => ({
         role: m.role,
         content: m.content,
     }));
-    // 입력 토큰 추정 (대략적)
+    // 입력 토큰 추정
     const estimateInputTokens = () => {
         let total = 0;
-        // 시스템 프롬프트
         if (systemPrompt) {
-            total += Math.ceil(systemPrompt.length / 3); // 대략 3자당 1토큰
+            total += Math.ceil(systemPrompt.length / 3);
         }
-        // 메시지들
         for (const msg of apiMessages) {
             const content = typeof msg.content === "string"
                 ? msg.content
@@ -112,37 +100,65 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", _thinking
         }
         return total;
     };
-    // 토큰 계산 (thinking 비활성화 - non-streaming에서 에러 발생)
     const inputTokens = estimateInputTokens();
-    const maxTokens = 8192;
-    console.log(`[Chat] model=${modelId}, input~${inputTokens}, maxTokens=${maxTokens}`);
-    // API 요청 파라미터 빌드 (도구 루프에서도 동일하게 사용)
-    const buildRequestParams = () => {
+    const { maxTokens, thinkingBudget } = calculateTokenBudgets(modelId, thinkingLevel, inputTokens);
+    console.log(`[Chat] model=${modelId}, thinking=${thinkingLevel}, input~${inputTokens}, maxTokens=${maxTokens}, budget=${thinkingBudget}`);
+    // 스트리밍 호출 (thinking 사용 가능)
+    const streamRequest = async () => {
         const params = {
             model: modelConfig.id,
             max_tokens: maxTokens,
             messages: apiMessages,
             tools: tools,
+            stream: true,
+        };
+        if (systemPrompt) {
+            params.system = systemPrompt;
+        }
+        // thinking 활성화
+        if (thinkingBudget > 0) {
+            params.thinking = {
+                type: "enabled",
+                budget_tokens: thinkingBudget,
+            };
+        }
+        // 스트리밍하되 최종 메시지만 반환
+        const stream = client.messages.stream(params);
+        return await stream.finalMessage();
+    };
+    // Non-streaming 호출 (도구 사용 루프용, thinking off)
+    const nonStreamRequest = async () => {
+        const params = {
+            model: modelConfig.id,
+            max_tokens: 8192,
+            messages: apiMessages,
+            tools: tools,
         };
         if (systemPrompt) {
             params.system = systemPrompt;
         }
-        return params;
+        return await client.messages.create(params);
     };
+    // 첫 번째 호출은 스트리밍 (thinking 사용)
     let response;
-    response = await withRetry(() => withTimeout(() => client.messages.create(buildRequestParams()), API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
-    // Tool use 루프 - Claude가 도구 사용을 멈출 때까지 반복
+    try {
+        response = await withRetry(() => withTimeout(streamRequest, API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
+    }
+    catch (error) {
+        // 스트리밍 실패 시 non-streaming 폴백
+        console.log("[Chat] Streaming failed, falling back to non-streaming");
+        response = await withRetry(() => withTimeout(nonStreamRequest, API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
+    }
+    // Tool use 루프 (non-streaming, thinking off)
     let iterations = 0;
     while (response.stop_reason === "tool_use" && iterations < MAX_TOOL_ITERATIONS) {
         iterations++;
         const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
-        // 도구 병렬 실행 (성능 최적화)
         console.log(`[Tool] Executing ${toolUseBlocks.length} tool(s) in parallel`);
         const toolExecutions = await Promise.all(toolUseBlocks.map(async (toolUse) => {
             const startTime = Date.now();
-            console.log(`[Tool] ${toolUse.name}:`, JSON.stringify(toolUse.input).slice(0, 200));
+            console.log(`[Tool] ${toolUse.name}:`, JSON.stringify(toolUse.input).slice(0, TOOL_INPUT_SUMMARY_LENGTH));
             try {
-                // 도구별 타임아웃 적용
                 const timeout = getToolTimeout(toolUse.name);
                 const result = await Promise.race([
                     executeTool(toolUse.name, toolUse.input),
@@ -150,32 +166,17 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", _thinking
                 ]);
                 const elapsed = Date.now() - startTime;
                 console.log(`[Tool] ${toolUse.name} completed in ${elapsed}ms`);
-                // 스마트 결과 압축
                 const compressedResult = compressToolResult(toolUse.name, result);
-                return {
-                    toolUse,
-                    result: compressedResult,
-                    success: true,
-                };
+                return { toolUse, result: compressedResult, success: true };
             }
             catch (error) {
                 const elapsed = Date.now() - startTime;
                 const errorMsg = error instanceof Error ? error.message : String(error);
                 console.error(`[Tool] ${toolUse.name} failed after ${elapsed}ms:`, errorMsg);
-                return {
-                    toolUse,
-                    result: `Error: ${errorMsg}`,
-                    success: false,
-                };
+                return { toolUse, result: `Error: ${errorMsg}`, success: false };
             }
         }));
-        // 결과 수집
-        const toolResults = toolExecutions.map((exec) => ({
-            type: "tool_result",
-            tool_use_id: exec.toolUse.id,
-            content: exec.result,
-        }));
-        // 도구 사용 기록
+        // 도구 결과 기록
         for (const exec of toolExecutions) {
             toolsUsed.push({
                 name: exec.toolUse.name,
@@ -183,34 +184,30 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", _thinking
                 output: exec.result.slice(0, TOOL_OUTPUT_SUMMARY_LENGTH),
             });
         }
-        // 어시스턴트 메시지와 도구 결과 추가
+        // 어시스턴트 메시지 추가 (도구 호출)
         apiMessages.push({
             role: "assistant",
             content: response.content,
         });
+        // 도구 결과 메시지 추가
         apiMessages.push({
             role: "user",
-            content: toolResults,
+            content: toolExecutions.map((exec) => ({
+                type: "tool_result",
+                tool_use_id: exec.toolUse.id,
+                content: exec.result,
+            })),
         });
-        // 다음 응답 요청 (도구 루프에서도 thinking 유지)
-        response = await withRetry(() => withTimeout(() => client.messages.create(buildRequestParams()), API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
-    }
-    // 반복 횟수 초과 시 경고
-    if (iterations >= MAX_TOOL_ITERATIONS) {
-        console.warn(`[Warning] Tool use loop reached max iterations (${MAX_TOOL_ITERATIONS})`);
-        return { text: "도구 실행이 너무 많이 반복됐어. 다시 시도해줄래?", toolsUsed };
+        // 다음 API 호출 (non-streaming, thinking off - 도구 결과 처리)
+        response = await withRetry(() => withTimeout(nonStreamRequest, API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
     }
-    // 최종 텍스트 응답 추출
-    const textBlock = response.content.find((block) => block.type === "text");
-    return {
-        text: textBlock?.text ?? "응답을 생성하지 못했어. 다시 시도해줄래?",
-        toolsUsed
-    };
+    // 최종 텍스트 추출
+    const textBlocks = response.content.filter((block) => block.type === "text");
+    const text = textBlocks.map((b) => b.text).join("\n");
+    return { text, toolsUsed };
 }
 /**
- * 스마트 채팅 - chat()의 단순 래퍼
- *
- * 도구 사용 여부를 별도로 반환하여 호출자가 구분할 수 있게 함
+ * chat()의 간단한 래퍼 - 도구 사용 여부 반환
  */
 export async function chatSmart(messages, systemPrompt, modelId, thinkingLevel = "medium") {
     const result = await chat(messages, systemPrompt, modelId, thinkingLevel);

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");
+}