appback-remoteagent 0.13.10 → 0.13.12

package/dist/bot.js

@@ -886,6 +886,14 @@ ${bridge.formatStatus(mapping)}`);
         if (!text) {
             return;
         }
+        if (mapping) {
+            const localStatus = await memoryService.formatLocalStatusQuestion(mapping.session, text);
+            if (localStatus) {
+                await bridge.logSystem(botId, chatId, "Answered local session status without provider execution.");
+                await reply(ctx, localStatus);
+                return;
+            }
+        }
         if (isRemoteShellMessage(text)) {
             const shellRequest = parseRemoteShellRequest(text);
             if (!shellRequest) {
@@ -1090,8 +1098,9 @@ async function runWithPendingAnimation(botToken, chatId, task) {
                 if (progressChunks.length === 0 && normalized.documents.length === 0) {
                     return;
                 }
-                const extra = parseMode ? { parse_mode: parseMode } : undefined;
-                for (const chunk of progressChunks) {
+                const rendered = formatProviderTelegramChunks(progressChunks, parseMode);
+                const extra = rendered.parseMode ? { parse_mode: rendered.parseMode } : undefined;
+                for (const chunk of rendered.chunks) {
                     await sendTelegramMessage(botToken, chatId, chunk, extra);
                 }
                 if (normalized.documents.length > 0) {
@@ -1102,12 +1111,13 @@ async function runWithPendingAnimation(botToken, chatId, task) {
         const result = await task(helpers);
         const normalized = await normalizeTelegramDelivery(result.chunks);
         const chunks = flattenChunks(normalized.chunks, 3900);
-        const extra = result.parseMode ? { parse_mode: result.parseMode } : undefined;
         if (chunks.length === 0 && normalized.documents.length === 0) {
             await sendTelegramMessage(botToken, chatId, "Response was empty.");
             return;
         }
-        for (const chunk of chunks) {
+        const rendered = formatProviderTelegramChunks(chunks, result.parseMode);
+        const extra = rendered.parseMode ? { parse_mode: rendered.parseMode } : undefined;
+        for (const chunk of rendered.chunks) {
             await sendTelegramMessage(botToken, chatId, chunk, extra);
         }
         if (normalized.documents.length > 0) {
@@ -1357,6 +1367,56 @@ function parseReportResponses(formattedBlocks, transform) {
     const chunks = transform(parsedBlocks.map((item) => item.text));
     return { kind, chunks };
 }
+function formatProviderTelegramChunks(chunks, explicitParseMode) {
+    if (explicitParseMode) {
+        return { chunks, parseMode: explicitParseMode };
+    }
+    return {
+        chunks: chunks.map((chunk) => renderTelegramHtml(chunk)),
+        parseMode: "HTML",
+    };
+}
+function renderTelegramHtml(text) {
+    const lines = text.split(/\r?\n/);
+    const rendered = [];
+    let codeFence;
+    for (const line of lines) {
+        if (/^```\w*\s*$/.test(line.trim())) {
+            if (codeFence) {
+                rendered.push(`<pre>${escapeTelegramHtml(codeFence.join("\n"))}</pre>`);
+                codeFence = undefined;
+            }
+            else {
+                codeFence = [];
+            }
+            continue;
+        }
+        if (codeFence) {
+            codeFence.push(line);
+            continue;
+        }
+        rendered.push(renderTelegramInlineHtml(line));
+    }
+    if (codeFence) {
+        rendered.push(`<pre>${escapeTelegramHtml(codeFence.join("\n"))}</pre>`);
+    }
+    return rendered.join("\n");
+}
+function renderTelegramInlineHtml(line) {
+    const parts = line.split(/(`[^`\n]+`)/g);
+    return parts.map((part) => {
+        if (part.startsWith("`") && part.endsWith("`") && part.length >= 2) {
+            return `<code>${escapeTelegramHtml(part.slice(1, -1))}</code>`;
+        }
+        return escapeTelegramHtml(part);
+    }).join("");
+}
+function escapeTelegramHtml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
 function looksLikeUntaggedIntentOnlyResponse(text) {
     const normalized = text.trim();
     if (!normalized) {

package/dist/services/agent-memory-service.js

@@ -71,6 +71,53 @@ export class AgentMemoryService {
             history.length > 0 ? ["Recent history:", ...history.map((entry) => `- ${entry}`)].join("\n") : undefined,
         ].filter(Boolean).join("\n");
     }
+    async formatLocalStatusQuestion(session, question) {
+        if (!this.looksLikeLocalStatusQuestion(question)) {
+            return undefined;
+        }
+        const current = await this.currentTaskText(session);
+        const todo = await this.readTodo(session);
+        const active = this.activeTodoItems(todo);
+        const history = await this.readRecentHistory(session, 8);
+        const workHistory = await this.readRecentWorkHistory(session, 6);
+        const latestInstruction = this.extractLatestInstructionFromCurrent(current);
+        const currentIsStatusOnly = latestInstruction ? this.looksLikeLocalStatusQuestion(latestInstruction) : false;
+        const hasCurrentWork = Boolean(current.trim()) && !currentIsStatusOnly;
+        const lines = [
+            `Session ${session.publicId} local state`,
+            "",
+            `workspace: ${session.workspace}`,
+            `memory: ${this.sessionDir(session)}`,
+            "",
+        ];
+        if (!hasCurrentWork && active.length === 0 && workHistory.length === 0) {
+            lines.push("현재 하네스 기준으로 진행 중이거나 완료된 작업 기록이 없습니다.", "이 세션은 깨끗한 상태로 보입니다.");
+        }
+        else {
+            if (hasCurrentWork) {
+                lines.push("Current note:", this.summarizeCurrentTask(current), "");
+            }
+            else {
+                lines.push("Current note: none", "");
+            }
+            if (active.length > 0) {
+                lines.push("Active TODO:", this.formatTodoSummary(todo, false), "");
+            }
+            else {
+                lines.push("Active TODO: none", "");
+            }
+            if (workHistory.length > 0) {
+                lines.push("Recent work history:", ...workHistory.map((entry) => `- ${entry}`));
+            }
+            else {
+                lines.push("Recent work history: none");
+            }
+        }
+        if (history.length > 0) {
+            lines.push("", "Recent raw history:", ...history.map((entry) => `- ${entry}`));
+        }
+        return lines.join("\n");
+    }
     async clearSessionState(session, summary) {
         const dir = this.sessionDir(session);
         const currentPath = path.join(dir, "current.md");
@@ -360,6 +407,17 @@ export class AgentMemoryService {
         return fs.readFile(path.join(this.sessionDir(session), "current.md"), "utf8").catch(() => "");
     }
     async readRecentHistory(session, limit) {
+        return (await this.readHistoryEntries(session, limit))
+            .slice(-limit)
+            .map((entry) => this.formatHistoryEntry(entry));
+    }
+    async readRecentWorkHistory(session, limit) {
+        return (await this.readHistoryEntries(session, 80))
+            .filter((entry) => ["progress", "completed", "archived", "note"].includes(String(entry.type ?? "")))
+            .slice(-limit)
+            .map((entry) => this.formatHistoryEntry(entry));
+    }
+    async readHistoryEntries(session, limit) {
         const historyPath = path.join(this.sessionDir(session), "history.ndjson");
         const raw = await fs.readFile(historyPath, "utf8").catch(() => "");
         return raw
@@ -369,16 +427,24 @@ export class AgentMemoryService {
             .slice(-limit)
             .map((line) => {
             try {
-                const entry = JSON.parse(line);
-                const kind = entry.mode ? `${entry.type ?? "event"}:${entry.mode}` : entry.type ?? "event";
-                const body = entry.summary ?? entry.text ?? entry.reason ?? "";
-                return `${entry.at ?? "unknown"} ${kind}: ${this.truncate(body.replace(/\s+/g, " ").trim(), 220)}`;
+                return JSON.parse(line);
             }
             catch {
-                return this.truncate(line.replace(/\s+/g, " ").trim(), 220);
+                return { type: "raw", text: line };
             }
         });
     }
+    formatHistoryEntry(entry) {
+        const type = typeof entry.type === "string" ? entry.type : "event";
+        const mode = typeof entry.mode === "string" ? entry.mode : undefined;
+        const at = typeof entry.at === "string" ? entry.at : "unknown";
+        const text = typeof entry.text === "string" ? entry.text : "";
+        const summary = typeof entry.summary === "string" ? entry.summary : "";
+        const reason = typeof entry.reason === "string" ? entry.reason : "";
+        const kind = mode ? `${type}:${mode}` : type;
+        const body = summary || text || reason || "";
+        return `${at} ${kind}: ${this.truncate(body.replace(/\s+/g, " ").trim(), 220)}`;
+    }
     todoPath(session) {
         return path.join(this.sessionDir(session), "todo.json");
     }
@@ -576,12 +642,35 @@ export class AgentMemoryService {
         return /^(새로|새\s*작업|다른\s*작업|이제\s*부터|다음\s*작업|전환|바꿔서|new task)/i.test(text.trim());
     }
     summarizeCurrentTask(current) {
+        const latestInstruction = this.extractLatestInstructionFromCurrent(current);
+        if (latestInstruction) {
+            return this.truncate(latestInstruction, 700);
+        }
         const instructionIndex = current.indexOf("## Instruction");
         const body = instructionIndex >= 0 ? current.slice(instructionIndex + "## Instruction".length) : current;
         const immediateRuleIndex = body.indexOf("## Immediate Rule");
         const instruction = (immediateRuleIndex >= 0 ? body.slice(0, immediateRuleIndex) : body).trim();
         return this.truncate(instruction || current.trim(), 700);
     }
+    extractLatestInstructionFromCurrent(current) {
+        const match = /## Latest User Instruction\s*\n([\s\S]*?)(?:\n## |\s*$)/.exec(current);
+        return match?.[1]?.trim() || undefined;
+    }
+    looksLikeLocalStatusQuestion(text) {
+        const normalized = text.trim();
+        if (!normalized) {
+            return false;
+        }
+        return [
+            /최근\s*(작업|진행|히스토리|기록)/,
+            /현재\s*(작업|진행|상태|세션)/,
+            /(뭐|무엇)\s*(하고|하는)\s*(있어|중|거야)?/,
+            /작업\s*(상태|히스토리|기록|있어|없어)/,
+            /세션\s*(상태|히스토리|기록)/,
+            /진행\s*(상태|중인\s*작업)/,
+            /\b(status|current work|recent work|what are you doing|session state)\b/i,
+        ].some((pattern) => pattern.test(normalized));
+    }
     formatTodoSummary(todo, includeDone = false, detailed = false) {
         const items = includeDone ? todo.items : todo.items.filter((item) => item.status !== "done");
         if (items.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appback-remoteagent",
-  "version": "0.13.10",
+  "version": "0.13.12",
   "description": "Personal installable session server for continuing local AI work across PC and Telegram",
   "license": "MIT",
   "type": "module",