poe-code 3.0.311 → 3.0.313

package/packages/memory/dist/install.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { installSkill } from "@poe-code/agent-skill-config";
-import { configure } from "@poe-code/agent-mcp-config";
+import { configure, resolveAgentSupport } from "@poe-code/agent-mcp-config";
 const SKILL_NAME = "poe-code-memory";
 export async function installMemory(options) {
     if (options.skillOnly && options.mcpOnly) {
@@ -46,9 +46,7 @@ export async function installMemory(options) {
             }
             throw error;
         }
-        mcpConfigPath = options.agent === "codex"
-            ? `${options.homeDir}/.config/codex/mcp-config.json`
-            : `${options.homeDir}/.mcp.json`;
+        mcpConfigPath = resolveMcpConfigPath(options.agent, options.homeDir, options.platform);
     }
     return {
         skillInstalled: !options.mcpOnly,
@@ -57,6 +55,16 @@ export async function installMemory(options) {
         mcpConfigPath
     };
 }
+function resolveMcpConfigPath(agent, homeDir, platform) {
+    const support = resolveAgentSupport(agent);
+    if (support.status !== "supported" || support.config === undefined) {
+        throw new Error(`Unsupported agent: ${agent}`);
+    }
+    const configFile = typeof support.config.configFile === "function"
+        ? support.config.configFile(platform)
+        : support.config.configFile;
+    return configFile.startsWith("~/") ? path.join(homeDir, configFile.slice(2)) : configFile;
+}
 async function removeInstalledSkill(options, skillPath) {
     const baseDir = options.scope === "global" ? options.homeDir : options.cwd;
     const displayPath = skillPath.startsWith("~/") ? skillPath.slice(2) : skillPath;

package/packages/memory/dist/paths.js

@@ -62,6 +62,9 @@ export async function assertMemoryRootIsNotSymlink(root) {
         try {
             const stat = await fs.lstat(currentPath);
             if (stat.isSymbolicLink()) {
+                if (await isAllowedMacSystemAlias(currentPath)) {
+                    continue;
+                }
                 throw new MemoryPathError(`Memory root "${root}" cannot be a symbolic link.`);
             }
         }
@@ -73,6 +76,18 @@ export async function assertMemoryRootIsNotSymlink(root) {
         }
     }
 }
+async function isAllowedMacSystemAlias(currentPath) {
+    if (currentPath !== "/var") {
+        return false;
+    }
+    try {
+        const target = await fs.readlink(currentPath);
+        return target === "/private/var" || target === "private/var";
+    }
+    catch {
+        return false;
+    }
+}
 function isMissing(error) {
     return hasOwnErrorCode(error, "ENOENT");
 }

package/packages/memory/dist/query.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { countTokens } from "tokenfill";
 import { spawn } from "@poe-code/agent-spawn";
 import { resolveAgent } from "@poe-code/poe-code-config";
+import { parseMemoryAgentResponse } from "./agent-response.js";
 import { listPages } from "./pages.js";
 import { MEMORY_INDEX_RELPATH } from "./paths.js";
 export async function queryMemory(root, options) {
@@ -24,7 +25,7 @@ export async function queryMemory(root, options) {
     const agentId = (await resolveAgent(configOptions, options.agent ?? null)) ?? options.agent ?? "claude-code";
     const context = await selectQueryContext(root, options.question, options.budget);
     const spawned = await spawn(agentId, { prompt: context.prompt });
-    const result = parseQueryResponse(spawned.stdout);
+    const result = parseMemoryAgentResponse(spawned.stdout);
     return {
         answer: result.answer,
         citations: result.citations,
@@ -33,30 +34,6 @@ export async function queryMemory(root, options) {
         exitCode: spawned.exitCode
     };
 }
-function parseQueryResponse(stdout) {
-    let value;
-    try {
-        value = JSON.parse(stdout);
-    }
-    catch {
-        throw new Error("Memory agent returned invalid JSON output.");
-    }
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        throw new Error("Memory agent returned an invalid result payload.");
-    }
-    const result = value;
-    if (typeof result.answer !== "string" ||
-        !Array.isArray(result.citations) ||
-        typeof result.tokensUsed !== "number" ||
-        !Number.isFinite(result.tokensUsed)) {
-        throw new Error("Memory agent returned an invalid result payload.");
-    }
-    return {
-        answer: result.answer,
-        citations: result.citations,
-        tokensUsed: result.tokensUsed
-    };
-}
 export async function selectQueryContext(root, question, budget) {
     if (!Number.isFinite(budget) || budget < 0) {
         throw new Error("budget must be a finite non-negative number");

package/packages/memory/dist/search.js

@@ -1,13 +1,13 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import { collectMarkdownRelPaths } from "./pages.js";
-import { assertNoSymlinkSegments } from "./paths.js";
+import { assertNoSymlinkSegments, MEMORY_PAGES_DIR_RELPATH } from "./paths.js";
 export async function searchMemory(root, query) {
     const normalizedQuery = query.trim();
     if (normalizedQuery.length === 0) {
         throw new Error("Search query cannot be empty.");
     }
-    const relPaths = await collectMarkdownRelPaths(root);
+    const relPaths = await collectMarkdownRelPaths(root, MEMORY_PAGES_DIR_RELPATH);
     const hits = [];
     for (const relPath of relPaths) {
         await assertNoSymlinkSegments(root, relPath);

package/packages/memory/dist/write.js

@@ -32,7 +32,7 @@ export async function appendToPage(root, relPath, content, opts) {
     const before = await snapshot(root);
     await fs.mkdir(path.dirname(pagePath), { recursive: true });
     await assertNoSymlinkSegments(root, pageRelPath);
-    const parsed = originalPage === undefined ? { frontmatter: {}, body: "" } : parseFrontmatter(originalPage);
+    const parsed = parseAppendTarget(originalPage, pageRelPath);
     try {
         await writeFileAtomically(pagePath, serializeFrontmatter(parsed.frontmatter, `${parsed.body}${content}`));
         return await reconcile(root, before, "update", opts.reason);
@@ -42,6 +42,19 @@ export async function appendToPage(root, relPath, content, opts) {
         throw error;
     }
 }
+function parseAppendTarget(originalPage, relPath) {
+    if (originalPage === undefined) {
+        return { frontmatter: {}, body: "" };
+    }
+    try {
+        return parseFrontmatter(originalPage);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to parse frontmatter for "${relPath}": ${message}`);
+        return { frontmatter: {}, body: originalPage };
+    }
+}
 export async function clearMemory(root) {
     await assertMemoryRootIsNotSymlink(root);
     const stagedRoot = `${root}.clear-${randomUUID()}`;