npm - @rubytech/taskmaster - Versions diffs - 1.0.111 → 1.1.0 - Mend

@rubytech/taskmaster 1.0.111 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/dist/agents/tools/document-tool.js +11 -2
package/dist/build-info.json +3 -3
package/dist/control-ui/assets/index-CfybK7_N.css +1 -0
package/dist/control-ui/assets/{index-Cp_azZBu.js → index-D7ZHRWnP.js} +212 -221
package/dist/control-ui/assets/index-D7ZHRWnP.js.map +1 -0
package/dist/control-ui/index.html +2 -2
package/dist/gateway/protocol/schema/sessions-transcript.js +3 -0
package/dist/gateway/server-chat.js +6 -0
package/dist/gateway/server-close.js +8 -0
package/dist/gateway/server-methods/chat.js +47 -0
package/dist/gateway/server-methods/sessions-transcript.js +56 -3
package/dist/gateway/server.impl.js +6 -0
package/dist/infra/heartbeat-auth-notify.js +99 -0
package/dist/infra/heartbeat-infra-alert.js +3 -0
package/dist/infra/heartbeat-runner.js +13 -2
package/dist/infra/infra-alert-events.js +16 -0
package/dist/memory/hybrid.js +12 -3
package/dist/memory/internal.js +116 -4
package/dist/memory/manager.js +8 -3
package/package.json +1 -1
package/dist/control-ui/assets/index-BM3zZtpB.css +0 -1
package/dist/control-ui/assets/index-Cp_azZBu.js.map +0 -1

package/dist/control-ui/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <title>Taskmaster Control</title>
     <meta name="color-scheme" content="dark light" />
     <link rel="icon" type="image/png" href="./favicon.png" />
-    <script type="module" crossorigin src="./assets/index-Cp_azZBu.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-BM3zZtpB.css">
+    <script type="module" crossorigin src="./assets/index-D7ZHRWnP.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-CfybK7_N.css">
   </head>
   <body>
     <taskmaster-app></taskmaster-app>

package/dist/gateway/protocol/schema/sessions-transcript.js CHANGED Viewed

@@ -13,6 +13,8 @@ export const SessionsTranscriptEntrySchema = Type.Object({
         Type.Literal("user"),
         Type.Literal("assistant"),
         Type.Literal("tool"),
+        Type.Literal("tool_call"),
+        Type.Literal("tool_result"),
         Type.Literal("thinking"),
         Type.Literal("error"),
         Type.Literal("system"),
@@ -20,6 +22,7 @@ export const SessionsTranscriptEntrySchema = Type.Object({
     content: Type.String(),
     model: Type.Optional(Type.String()),
     toolName: Type.Optional(Type.String()),
+    toolCallId: Type.Optional(Type.String()),
     meta: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
 });
 export const SessionsTranscriptResultSchema = Type.Object({

package/dist/gateway/server-chat.js CHANGED Viewed

@@ -46,17 +46,20 @@ export function createChatRunState() {
     const buffers = new Map();
     const deltaSentAt = new Map();
     const abortedRuns = new Map();
+    const finalHadContent = new Map();
     const clear = () => {
         registry.clear();
         buffers.clear();
         deltaSentAt.clear();
         abortedRuns.clear();
+        finalHadContent.clear();
     };
     return {
         registry,
         buffers,
         deltaSentAt,
         abortedRuns,
+        finalHadContent,
         clear,
     };
 }
@@ -91,6 +94,9 @@ export function createAgentEventHandler({ broadcast, nodeSendToSession, agentRun
         chatRunState.deltaSentAt.delete(clientRunId);
         // Strip silent reply token so it never reaches the chat UI
         const text = isSilentReplyText(rawText) ? "" : rawText;
+        // Record whether the streaming buffer had content so the chat.send .then()
+        // handler knows whether it needs to broadcast the dispatcher's final reply.
+        chatRunState.finalHadContent.set(clientRunId, !!text);
         if (jobState === "done") {
             const payload = {
                 runId: clientRunId,

package/dist/gateway/server-close.js CHANGED Viewed

@@ -72,6 +72,14 @@ export function createGatewayCloseHandler(params) {
                 /* ignore */
             }
         }
+        if (params.infraAlertUnsub) {
+            try {
+                params.infraAlertUnsub();
+            }
+            catch {
+                /* ignore */
+            }
+        }
         params.chatRunState.clear();
         for (const c of params.clients) {
             try {

package/dist/gateway/server-methods/chat.js CHANGED Viewed

@@ -604,6 +604,52 @@ export const chatHandlers = {
                         message,
                     });
                 }
+                else if (finalReplyParts.length > 0) {
+                    // Agent started but the reply came through the dispatcher, not
+                    // streaming (e.g. auth error, billing error, context overflow).
+                    // emitChatFinal already broadcast a "final" — check whether it
+                    // had content.  If the streaming buffer was empty, the dispatcher's
+                    // reply was the only response and needs to be persisted + broadcast.
+                    const agentStreamedContent = context.chatFinalHadContent.get(clientRunId) ?? false;
+                    if (!agentStreamedContent) {
+                        const combinedReply = finalReplyParts
+                            .map((part) => part.trim())
+                            .filter(Boolean)
+                            .join("\n\n")
+                            .trim();
+                        if (combinedReply) {
+                            const { storePath: latestStorePath, entry: latestEntry } = loadSessionEntry(p.sessionKey);
+                            const sessionId = latestEntry?.sessionId ?? entry?.sessionId ?? clientRunId;
+                            const appended = appendAssistantTranscriptMessage({
+                                message: combinedReply,
+                                sessionId,
+                                storePath: latestStorePath,
+                                sessionFile: latestEntry?.sessionFile,
+                                createIfMissing: true,
+                            });
+                            let message;
+                            if (appended.ok) {
+                                message = appended.message;
+                            }
+                            else {
+                                context.logGateway.warn(`webchat transcript append (fallback) failed: ${appended.error ?? "unknown error"}`);
+                                message = {
+                                    role: "assistant",
+                                    content: [{ type: "text", text: combinedReply }],
+                                    timestamp: Date.now(),
+                                    stopReason: "injected",
+                                    usage: { input: 0, output: 0, totalTokens: 0 },
+                                };
+                            }
+                            broadcastChatFinal({
+                                context,
+                                runId: clientRunId,
+                                sessionKey: p.sessionKey,
+                                message,
+                            });
+                        }
+                    }
+                }
                 // Fire message:outbound hook for conversation archiving
                 const outboundText = finalReplyParts.join("\n\n").trim();
                 if (outboundText) {
@@ -644,6 +690,7 @@ export const chatHandlers = {
             })
                 .finally(() => {
                 context.chatAbortControllers.delete(clientRunId);
+                context.chatFinalHadContent.delete(clientRunId);
             });
         }
         catch (err) {

package/dist/gateway/server-methods/sessions-transcript.js CHANGED Viewed

@@ -30,6 +30,28 @@ function extractTextFromContentBlocks(blocks) {
     }
     return parts.join("\n");
 }
+/** Format tool input as readable key=value pairs instead of raw JSON. */
+function formatToolInput(input) {
+    if (input == null)
+        return "";
+    if (typeof input === "string")
+        return input;
+    if (typeof input !== "object" || Array.isArray(input))
+        return JSON.stringify(input);
+    const obj = input;
+    const parts = [];
+    for (const [key, val] of Object.entries(obj)) {
+        if (val === undefined)
+            continue;
+        const valStr = typeof val === "string"
+            ? val.length > 200
+                ? `"${val.slice(0, 200)}..."`
+                : `"${val}"`
+            : JSON.stringify(val);
+        parts.push(`${key}: ${valStr}`);
+    }
+    return parts.join("\n");
+}
 function expandLineToEntries(line, sessionId, sessionKey, agentId, fileMtimeMs) {
     const entries = [];
     const ts = resolveTimestamp(line, fileMtimeMs);
@@ -64,9 +86,10 @@ function expandLineToEntries(line, sessionId, sessionKey, agentId, fileMtimeMs)
             sessionKey,
             agentId,
             timestamp: ts,
-            type: "tool",
+            type: "tool_result",
             content,
             ...(line.toolName ? { toolName: line.toolName } : {}),
+            ...(line.toolCallId ? { toolCallId: line.toolCallId } : {}),
             ...(model ? { model } : {}),
         });
         return entries;
@@ -74,6 +97,34 @@ function expandLineToEntries(line, sessionId, sessionKey, agentId, fileMtimeMs)
     if (line.type === "message" && line.message) {
         const msg = line.message;
         const contentBlocks = Array.isArray(msg.content) ? msg.content : [];
+        // Handle toolResult messages — these are separate JSONL lines from the SDK
+        // with role: "toolResult", toolCallId, toolName, and content blocks.
+        if (msg.role === "toolResult") {
+            const textParts = [];
+            for (const block of contentBlocks) {
+                if (block && typeof block === "object" && typeof block.text === "string" && block.text.trim()) {
+                    textParts.push(block.text.trim());
+                }
+            }
+            if (typeof msg.content === "string" && msg.content.trim()) {
+                textParts.push(msg.content.trim());
+            }
+            const content = textParts.length > 0 ? textParts.join("\n") : "(empty result)";
+            const toolName = typeof msg.toolName === "string" ? msg.toolName : undefined;
+            const toolCallId = typeof msg.toolCallId === "string" ? msg.toolCallId : undefined;
+            entries.push({
+                sessionId,
+                sessionKey,
+                agentId,
+                timestamp: ts,
+                type: "tool_result",
+                content: msg.isError ? `[error] ${content}` : content,
+                ...(toolName ? { toolName } : {}),
+                ...(toolCallId ? { toolCallId } : {}),
+                ...(model ? { model } : {}),
+            });
+            return entries;
+        }
         // If content is a simple string (not blocks), treat as a single text entry
         if (typeof msg.content === "string") {
             const role = msg.role;
@@ -111,15 +162,17 @@ function expandLineToEntries(line, sessionId, sessionKey, agentId, fileMtimeMs)
             else if (blockType === "tool_use" || blockType === "toolCall") {
                 const toolName = typeof block.name === "string" ? block.name : undefined;
                 const input = blockType === "toolCall" ? block.arguments : block.input;
-                const content = input != null ? JSON.stringify(input) : "";
+                const content = formatToolInput(input);
+                const blockId = typeof block.id === "string" ? block.id : undefined;
                 entries.push({
                     sessionId,
                     sessionKey,
                     agentId,
                     timestamp: ts,
-                    type: "tool",
+                    type: "tool_call",
                     content,
                     ...(toolName ? { toolName } : {}),
+                    ...(blockId ? { toolCallId: blockId } : {}),
                     ...(model ? { model } : {}),
                 });
             }

package/dist/gateway/server.impl.js CHANGED Viewed

@@ -13,6 +13,7 @@ import { applyPluginAutoEnable } from "../config/plugin-auto-enable.js";
 import { clearAgentRunContext, onAgentEvent } from "../infra/agent-events.js";
 import { onHeartbeatEvent } from "../infra/heartbeat-events.js";
 import { startHeartbeatRunner } from "../infra/heartbeat-runner.js";
+import { onInfraAlertEvent } from "../infra/infra-alert-events.js";
 import { getMachineDisplayName } from "../infra/machine-name.js";
 import { ensureTaskmasterCliOnPath } from "../infra/path-env.js";
 import { primeRemoteSkillsCache, refreshRemoteBinsForConnectedNodes, setSkillsRemoteRegistry, } from "../infra/skills-remote.js";
@@ -327,6 +328,9 @@ export async function startGatewayServer(port = 18789, opts = {}) {
     const heartbeatUnsub = onHeartbeatEvent((evt) => {
         broadcast("heartbeat", evt, { dropIfSlow: true });
     });
+    const infraAlertUnsub = onInfraAlertEvent((evt) => {
+        broadcast("notification", evt);
+    });
     let heartbeatRunner = startHeartbeatRunner({ cfg: cfgAtStart });
     void cron.start().catch((err) => logCron.error(`failed to start: ${String(err)}`));
     const execApprovalManager = new ExecApprovalManager();
@@ -376,6 +380,7 @@ export async function startGatewayServer(port = 18789, opts = {}) {
             chatAbortControllers,
             chatAbortedRuns: chatRunState.abortedRuns,
             chatRunBuffers: chatRunState.buffers,
+            chatFinalHadContent: chatRunState.finalHadContent,
             chatDeltaSentAt: chatRunState.deltaSentAt,
             addChatRun,
             removeChatRun,
@@ -494,6 +499,7 @@ export async function startGatewayServer(port = 18789, opts = {}) {
         dedupeCleanup,
         agentUnsub,
         heartbeatUnsub,
+        infraAlertUnsub,
         chatRunState,
         clients,
         configReloader,

package/dist/infra/heartbeat-auth-notify.js ADDED Viewed

@@ -0,0 +1,99 @@
+import { buildAuthHealthSummary, formatRemainingShort, } from "../agents/auth-health.js";
+import { loadAuthProfileStore } from "../agents/auth-profiles.js";
+import { getChannelPlugin } from "../channels/plugins/index.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+import { emitInfraAlertEvent } from "./infra-alert-events.js";
+import { deliverOutboundPayloads } from "./outbound/deliver.js";
+const log = createSubsystemLogger("gateway/heartbeat-auth-notify");
+const COOLDOWN_MS = 6 * 60 * 60 * 1000; // 6 hours — same as infra alerts
+let lastNotifiedMs = 0;
+function formatAuthAlertMessage(summary) {
+    const problems = summary.providers.filter((p) => p.status === "expired" || p.status === "expiring");
+    if (problems.length === 0)
+        return null;
+    const parts = [];
+    for (const provider of problems) {
+        const name = provider.provider.charAt(0).toUpperCase() + provider.provider.slice(1);
+        if (provider.status === "expired") {
+            parts.push(`${name} API key has expired`);
+        }
+        else if (provider.status === "expiring") {
+            const remaining = formatRemainingShort(provider.remainingMs);
+            parts.push(`${name} API key expires in ${remaining}`);
+        }
+    }
+    if (parts.length === 0)
+        return null;
+    const detail = parts.join("; ");
+    return `${detail}. Open the control panel and go to Settings > API Keys to update.`;
+}
+/**
+ * Proactive auth health check — runs after each heartbeat cycle to detect
+ * expired or soon-to-expire API tokens and notify the admin before they
+ * encounter errors.
+ *
+ * Alerts go to both the delivery channel (WhatsApp/iMessage) and the
+ * Control Panel via the infra-alert event bus.
+ *
+ * Returns true if an alert was sent, false otherwise. Never throws.
+ */
+export async function checkAndNotifyAuthHealth(params) {
+    try {
+        const { cfg, delivery, deps } = params;
+        const nowMs = params.nowMs ?? Date.now();
+        // Cooldown: don't spam the admin.
+        if (nowMs - lastNotifiedMs < COOLDOWN_MS)
+            return false;
+        const store = loadAuthProfileStore();
+        const summary = buildAuthHealthSummary({ store, cfg });
+        const message = formatAuthAlertMessage(summary);
+        if (!message)
+            return false;
+        // Always broadcast to Control Panel regardless of delivery channel.
+        emitInfraAlertEvent({ category: "auth", message });
+        // Deliver via WhatsApp/iMessage if target available.
+        if (delivery.channel !== "none" && delivery.to) {
+            const plugin = getChannelPlugin(delivery.channel);
+            if (plugin?.heartbeat?.checkReady) {
+                const readiness = await plugin.heartbeat.checkReady({
+                    cfg,
+                    accountId: delivery.accountId,
+                    deps,
+                });
+                if (!readiness.ok) {
+                    log.debug("auth notify skipped channel delivery: not ready", {
+                        reason: readiness.reason,
+                    });
+                    lastNotifiedMs = nowMs;
+                    return true; // CP was still notified
+                }
+            }
+            await deliverOutboundPayloads({
+                cfg,
+                channel: delivery.channel,
+                to: delivery.to,
+                accountId: delivery.accountId,
+                payloads: [{ text: message }],
+                deps,
+            });
+        }
+        lastNotifiedMs = nowMs;
+        log.info("auth health alert sent", {
+            to: delivery.to ?? "control-panel-only",
+            problems: summary.providers
+                .filter((p) => p.status === "expired" || p.status === "expiring")
+                .map((p) => `${p.provider}:${p.status}`),
+        });
+        return true;
+    }
+    catch (err) {
+        log.error("auth health check failed", {
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return false;
+    }
+}
+/** Reset cooldown timer. Exposed for testing. */
+export function resetAuthNotifyCooldown() {
+    lastNotifiedMs = 0;
+}

package/dist/infra/heartbeat-infra-alert.js CHANGED Viewed

@@ -1,6 +1,7 @@
 import { describeFailoverError } from "../agents/failover-error.js";
 import { getChannelPlugin } from "../channels/plugins/index.js";
 import { createSubsystemLogger } from "../logging/subsystem.js";
+import { emitInfraAlertEvent } from "./infra-alert-events.js";
 import { deliverOutboundPayloads } from "./outbound/deliver.js";
 const log = createSubsystemLogger("gateway/heartbeat-infra-alert");
 const COOLDOWN_MS = 6 * 60 * 60 * 1000; // 6 hours
@@ -79,6 +80,7 @@ export async function maybeAlertAdmin(ctx) {
                 payloads: [{ text: message }],
                 deps,
             });
+            emitInfraAlertEvent({ category, message });
             cooldowns.set(category, nowMs);
             log.info("infra alert sent", { category, to: delivery.to });
             return true;
@@ -115,6 +117,7 @@ export async function maybeAlertAdmin(ctx) {
                 payloads: [{ text: message }],
                 deps,
             });
+            emitInfraAlertEvent({ category, message });
             cooldowns.set(category, nowMs);
             log.info("infra alert sent", {
                 category,

package/dist/infra/heartbeat-runner.js CHANGED Viewed

@@ -25,6 +25,7 @@ import { resolveHeartbeatVisibility } from "./heartbeat-visibility.js";
 import { requestHeartbeatNow, setHeartbeatWakeHandler, } from "./heartbeat-wake.js";
 import { deliverOutboundPayloads } from "./outbound/deliver.js";
 import { resolveHeartbeatDeliveryTarget, resolveHeartbeatSenderContext, } from "./outbound/targets.js";
+import { checkAndNotifyAuthHealth } from "./heartbeat-auth-notify.js";
 import { maybeNotifyUpdateAvailable } from "./heartbeat-update-notify.js";
 const log = createSubsystemLogger("gateway/heartbeat");
 let heartbeatsEnabled = true;
@@ -630,6 +631,14 @@ async function checkAndNotifyUpdate(cfg, agent, deps) {
     const delivery = resolveHeartbeatDeliveryTarget({ cfg, entry, heartbeat, bindingAccountId });
     await maybeNotifyUpdateAvailable({ cfg, delivery, deps });
 }
+async function checkAuthHealth(cfg, agent, deps) {
+    const agentId = agent.agentId;
+    const heartbeat = agent.heartbeat;
+    const { entry } = resolveHeartbeatSession(cfg, agentId, heartbeat);
+    const bindingAccountId = resolveAgentBoundAccountId(cfg, agentId, "whatsapp") ?? undefined;
+    const delivery = resolveHeartbeatDeliveryTarget({ cfg, entry, heartbeat, bindingAccountId });
+    await checkAndNotifyAuthHealth({ cfg, delivery, deps });
+}
 export function startHeartbeatRunner(opts) {
     const runtime = opts.runtime ?? defaultRuntime;
     const runOnce = opts.runOnce ?? runHeartbeatOnce;
@@ -751,12 +760,14 @@ export function startHeartbeatRunner(opts) {
             if (res.status === "ran")
                 ran = true;
         }
-        // After heartbeat cycle: check for software updates and notify admin.
+        // After heartbeat cycle: check for software updates and auth health, notify admin.
         // Uses the first agent's delivery target. Non-blocking — never delays the next heartbeat.
         if (ran) {
             const firstAgent = state.agents.values().next().value;
             if (firstAgent) {
-                void checkAndNotifyUpdate(state.cfg, firstAgent, { runtime: state.runtime }).catch(() => { });
+                const postRunDeps = { runtime: state.runtime };
+                void checkAndNotifyUpdate(state.cfg, firstAgent, postRunDeps).catch(() => { });
+                void checkAuthHealth(state.cfg, firstAgent, postRunDeps).catch(() => { });
             }
         }
         scheduleNext();

package/dist/infra/infra-alert-events.js ADDED Viewed

@@ -0,0 +1,16 @@
+const listeners = new Set();
+export function emitInfraAlertEvent(evt) {
+    const enriched = { ts: Date.now(), ...evt };
+    for (const listener of listeners) {
+        try {
+            listener(enriched);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export function onInfraAlertEvent(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}

package/dist/memory/hybrid.js CHANGED Viewed

@@ -9,8 +9,10 @@ export function buildFtsQuery(raw) {
     return quoted.join(" AND ");
 }
 export function bm25RankToScore(rank) {
-    const normalized = Number.isFinite(rank) ? Math.max(0, rank) : 999;
-    return 1 / (1 + normalized);
+    // FTS5 bm25() returns negative values (more negative = more relevant).
+    // Convert to 0-1 scale: absRank/(1+absRank) → higher for better matches.
+    const absRank = Number.isFinite(rank) ? Math.abs(rank) : 0;
+    return absRank / (1 + absRank);
 }
 /**
  * Path-based boost factors applied during hybrid merge.
@@ -73,7 +75,14 @@ export function mergeHybridResults(params) {
         }
     }
     const merged = Array.from(byId.values()).map((entry) => {
-        const raw = params.vectorWeight * entry.vectorScore + params.textWeight * entry.textScore;
+        const weighted = params.vectorWeight * entry.vectorScore + params.textWeight * entry.textScore;
+        // Keyword-only results (found by FTS but missed by vector search) must not be
+        // capped by textWeight — their text score passes through directly so exact keyword
+        // matches remain visible above minScore. When both signals are present, the weighted
+        // formula controls ranking as configured.
+        const raw = entry.vectorScore === 0 && entry.textScore > 0
+            ? Math.max(weighted, entry.textScore)
+            : weighted;
         const score = raw * pathBoost(entry.path);
         return {
             path: entry.path,

package/dist/memory/internal.js CHANGED Viewed

@@ -2,6 +2,21 @@ import crypto from "node:crypto";
 import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
+/**
+ * File extensions indexed by the memory system.
+ * Text-based formats are read as UTF-8; binary formats require extraction.
+ */
+const TEXT_EXTENSIONS = new Set([".md", ".txt", ".html", ".htm", ".csv", ".json"]);
+const BINARY_EXTENSIONS = new Set([".pdf", ".docx", ".xlsx", ".pptx"]);
+const MEMORY_FILE_EXTENSIONS = new Set([...TEXT_EXTENSIONS, ...BINARY_EXTENSIONS]);
+function isMemoryFileExtension(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return MEMORY_FILE_EXTENSIONS.has(ext);
+}
+export function isBinaryMemoryFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return BINARY_EXTENSIONS.has(ext);
+}
 export function ensureDir(dir) {
     try {
         fsSync.mkdirSync(dir, { recursive: true });
@@ -41,7 +56,7 @@ async function walkDir(dir, files) {
                 if (stat.isDirectory()) {
                     await walkDir(full, files);
                 }
-                else if (stat.isFile() && entry.name.endsWith(".md")) {
+                else if (stat.isFile() && isMemoryFileExtension(entry.name)) {
                     files.push(full);
                 }
             }
@@ -56,7 +71,7 @@ async function walkDir(dir, files) {
         }
         if (!entry.isFile())
             continue;
-        if (!entry.name.endsWith(".md"))
+        if (!isMemoryFileExtension(entry.name))
             continue;
         files.push(full);
     }
@@ -95,8 +110,11 @@ export function hashText(value) {
 }
 export async function buildFileEntry(absPath, workspaceDir) {
     const stat = await fs.stat(absPath);
-    const content = await fs.readFile(absPath, "utf-8");
-    const hash = hashText(content);
+    // Binary files (PDF, DOCX, etc.) are hashed from raw bytes; text files from UTF-8.
+    const binary = isBinaryMemoryFile(absPath);
+    const hash = binary
+        ? crypto.createHash("sha256").update(await fs.readFile(absPath)).digest("hex")
+        : hashText(await fs.readFile(absPath, "utf-8"));
     return {
         path: path.relative(workspaceDir, absPath).replace(/\\/g, "/"),
         absPath,
@@ -301,3 +319,97 @@ export function extractPeerFromPath(relPath) {
     const match = relPath.match(/^memory\/users\/([^/]+)\//i);
     return match?.[1];
 }
+// ---------------------------------------------------------------------------
+// Document content extraction for memory indexing
+// ---------------------------------------------------------------------------
+/**
+ * Strip HTML tags and decode common entities, producing plain text for indexing.
+ */
+export function stripHtmlTags(html) {
+    return html
+        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
+        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(?:p|div|h[1-6]|li|tr|blockquote)>/gi, "\n")
+        .replace(/<[^>]+>/g, " ")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#0?39;/g, "'")
+        .replace(/[ \t]+/g, " ")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+/**
+ * Extract indexable text content from a memory file.
+ *
+ * - `.md`, `.txt`, `.csv`, `.json` — read as UTF-8
+ * - `.html`, `.htm` — strip HTML tags
+ * - `.pdf` — extract via pdfjs-dist (lazy-loaded)
+ * - `.docx` — extract via mammoth (lazy-loaded)
+ * - `.xlsx` — extract via JSZip (lazy-loaded)
+ * - `.pptx` — extract via JSZip (lazy-loaded)
+ *
+ * Returns empty string if extraction fails (logged, not thrown).
+ */
+export async function extractMemoryFileContent(absPath) {
+    const ext = path.extname(absPath).toLowerCase();
+    try {
+        switch (ext) {
+            case ".md":
+            case ".txt":
+            case ".csv":
+            case ".json":
+                return await fs.readFile(absPath, "utf-8");
+            case ".html":
+            case ".htm":
+                return stripHtmlTags(await fs.readFile(absPath, "utf-8"));
+            case ".pdf": {
+                const buffer = await fs.readFile(absPath);
+                const { getDocument } = await import("pdfjs-dist/legacy/build/pdf.mjs");
+                const pdf = await getDocument({ data: new Uint8Array(buffer), disableWorker: true })
+                    .promise;
+                const parts = [];
+                for (let i = 1; i <= pdf.numPages; i++) {
+                    const page = await pdf.getPage(i);
+                    const tc = await page.getTextContent();
+                    const text = tc.items
+                        .map((item) => ("str" in item ? String(item.str) : ""))
+                        .filter(Boolean)
+                        .join(" ");
+                    if (text.trim())
+                        parts.push(text);
+                }
+                return parts.join("\n\n");
+            }
+            case ".docx": {
+                const buffer = await fs.readFile(absPath);
+                const { extractDocxContent } = await import("../media/document-extract.js");
+                const result = await extractDocxContent(buffer);
+                return result.text;
+            }
+            case ".xlsx": {
+                const buffer = await fs.readFile(absPath);
+                const { extractXlsxContent } = await import("../media/document-extract.js");
+                const result = await extractXlsxContent(buffer);
+                return result.text;
+            }
+            case ".pptx": {
+                const buffer = await fs.readFile(absPath);
+                const { extractPptxContent } = await import("../media/document-extract.js");
+                const result = await extractPptxContent(buffer);
+                return result.text;
+            }
+            default:
+                return await fs.readFile(absPath, "utf-8");
+        }
+    }
+    catch (err) {
+        // Extraction failure should not crash indexing — the file is skipped.
+        // Log the error so it's diagnosable (not silently swallowed).
+        console.warn(`[memory] extraction failed for ${path.basename(absPath)}: ${err instanceof Error ? err.message : String(err)}`);
+        return "";
+    }
+}

package/dist/memory/manager.js CHANGED Viewed

@@ -16,7 +16,7 @@ import { DEFAULT_GEMINI_EMBEDDING_MODEL } from "./embeddings-gemini.js";
 import { DEFAULT_OPENAI_EMBEDDING_MODEL } from "./embeddings-openai.js";
 import { OPENAI_BATCH_ENDPOINT, runOpenAiEmbeddingBatches, } from "./batch-openai.js";
 import { runGeminiEmbeddingBatches } from "./batch-gemini.js";
-import { buildFileEntry, chunkMarkdown, ensureDir, extractPeerFromPath, hashText, isMemoryPath, listMemoryFiles, normalizeRelPath, parseEmbedding, } from "./internal.js";
+import { buildFileEntry, chunkMarkdown, ensureDir, extractMemoryFileContent, extractPeerFromPath, hashText, isBinaryMemoryFile, isMemoryPath, listMemoryFiles, normalizeRelPath, parseEmbedding, } from "./internal.js";
 import { bm25RankToScore, buildFtsQuery, mergeHybridResults } from "./hybrid.js";
 import { searchKeyword, searchVector } from "./manager-search.js";
 import { ensureMemoryIndexSchema } from "./memory-schema.js";
@@ -545,7 +545,10 @@ export class MemoryIndexManager {
         if (!absPath.startsWith(this.workspaceDir)) {
             throw new Error("path escapes workspace");
         }
-        const content = await fs.readFile(absPath, "utf-8");
+        // Binary/document files return extracted text; text files read as UTF-8.
+        const content = isBinaryMemoryFile(absPath)
+            ? await extractMemoryFileContent(absPath)
+            : await fs.readFile(absPath, "utf-8");
         if (!params.from && !params.lines) {
             return { text: content, path: relPath };
         }
@@ -2253,7 +2256,9 @@ export class MemoryIndexManager {
         return this.batch.enabled ? this.batch.concurrency : EMBEDDING_INDEX_CONCURRENCY;
     }
     async indexFile(entry, options) {
-        const content = options.content ?? (await fs.readFile(entry.absPath, "utf-8"));
+        const content = options.content ?? (await extractMemoryFileContent(entry.absPath));
+        if (!content)
+            return; // Extraction failed — skip silently (logged in extractMemoryFileContent)
         const chunks = chunkMarkdown(content, this.settings.chunking).filter((chunk) => chunk.text.trim().length > 0);
         const embeddings = this.batch.enabled
             ? await this.embedChunksWithBatch(chunks, entry, options.source)