codex-dev-mcp-suite 1.1.0 → 1.3.0

package/project-memory/rerank.js

@@ -1,14 +1,14 @@
 /**
  * LLM reranker via any OpenAI-compatible /v1/chat/completions model.
- * Used when embeddings are unavailable: keyword prefilter -> LLM picks the
- * most relevant candidates. Degrades gracefully: returns null on any failure
- * so callers fall back to keyword ordering. Never throws.
+ * Tries provider chain slots in order, skipping any currently cooling down
+ * after a recent failure. Degrades gracefully: returns null on any failure so
+ * callers fall back to keyword ordering. Never throws. Never logs keys/bodies.
  */
 import http from "http";
 import https from "https";
 import { URL } from "url";
 import { deterministicEnabled } from "./env.js";
-import { providerChainConfig } from "./provider-chain.js";
+import { providerChainConfig, isCoolingDown, recordOutcome } from "./provider-chain.js";
 
 const TIMEOUT_MS = Number(process.env.RERANK_TIMEOUT_MS || 30000);
 const ENABLED = process.env.RERANK_ENABLED !== "0";
@@ -25,10 +25,19 @@ export function rerankConfig() {
   };
 }
 
+function providerKey(provider) {
+  return `${provider.label}|${provider.base}|${provider.model}`;
+}
+
+/**
+ * Resolves { content, retryable }. retryable=true means try the next provider
+ * (timeout, network error, 429, or 5xx). retryable=false with null content
+ * means a definitive non-retryable response (e.g. 4xx auth).
+ */
 function chatWithProvider(provider, messages) {
   return new Promise((resolve) => {
     let u;
-    try { u = new URL("/v1/chat/completions", provider.base); } catch { return resolve(null); }
+    try { u = new URL("/v1/chat/completions", provider.base); } catch { return resolve({ content: null, retryable: false }); }
     const payload = Buffer.from(JSON.stringify({ model: provider.model, stream: false, temperature: 0, max_tokens: 200, messages }));
     const lib = u.protocol === "https:" ? https : http;
     const req = lib.request(
@@ -44,10 +53,14 @@ function chatWithProvider(provider, messages) {
         let body = "";
         res.on("data", (c) => (body += c));
         res.on("end", () => {
-          if (res.statusCode !== 200) return resolve(null);
+          const status = res.statusCode || 0;
+          if (status !== 200) {
+            const retryable = status === 429 || status >= 500;
+            return resolve({ content: null, retryable });
+          }
           try {
             const j = JSON.parse(body);
-            return resolve(j?.choices?.[0]?.message?.content ?? null);
+            return resolve({ content: j?.choices?.[0]?.message?.content ?? null, retryable: false });
           } catch { /* maybe SSE */ }
           try {
             let acc = "";
@@ -59,13 +72,13 @@ function chatWithProvider(provider, messages) {
               const j = JSON.parse(d);
               acc += j?.choices?.[0]?.delta?.content || j?.choices?.[0]?.message?.content || "";
             }
-            return resolve(acc || null);
-          } catch { return resolve(null); }
+            return resolve({ content: acc || null, retryable: false });
+          } catch { return resolve({ content: null, retryable: true }); }
         });
       }
     );
-    req.on("error", () => resolve(null));
-    req.on("timeout", () => { req.destroy(); resolve(null); });
+    req.on("error", () => resolve({ content: null, retryable: true }));
+    req.on("timeout", () => { req.destroy(); resolve({ content: null, retryable: true }); });
     req.write(payload);
     req.end();
   });
@@ -75,8 +88,11 @@ async function chat(messages) {
   if (!ENABLED || deterministicEnabled()) return null;
   const { providers } = providerChainConfig();
   for (const provider of providers) {
-    const out = await chatWithProvider(provider, messages);
-    if (out) return out;
+    const key = providerKey(provider);
+    if (isCoolingDown(key)) continue;
+    const { content, retryable } = await chatWithProvider(provider, messages);
+    if (content) { recordOutcome(key, true); return content; }
+    if (retryable) recordOutcome(key, false);
   }
   return null;
 }

package/project-memory/server.js

@@ -29,6 +29,7 @@ import crypto from "crypto";
 import { embed, embedOne, cosine, embeddingConfig } from "./embedding.js";
 import { rerank, rerankConfig } from "./rerank.js";
 import { deterministicEnabled } from "./env.js";
+import { computeStats, formatText, formatJson } from "../lib/stats.js";
 
 const VAULT_ROOT =
   process.env.MEMORY_VAULT_DIR ||
@@ -220,6 +221,18 @@ class ProjectMemoryServer {
             },
           },
         },
+        {
+          name: "memory_stats",
+          description: "Summarize local memory storage across vault / journal / checkpoints: totals, top projects, recent activity, and temp-slug cleanup candidates. Returns the same text as the `stats` CLI.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              root: { type: "string", description: "Storage root (default: ~/.codex/memories or first env var of MEMORY_VAULT_DIR / JOURNAL_DIR / CHECKPOINT_DIR)" },
+              top: { type: "number", description: "How many entries in top-project / recent-activity lists (default 10)", default: 10 },
+              json: { type: "boolean", description: "Return machine-readable JSON instead of human text", default: false },
+            },
+          },
+        },
       ],
     }));
 
@@ -233,6 +246,7 @@ class ProjectMemoryServer {
           case "memory_get": return await this.get(args || {});
           case "memory_delete": return await this.del(args || {});
           case "memory_reindex": return await this.reindex(args || {});
+          case "memory_stats": return await this.stats(args || {});
           default: throw new Error(`Unknown tool: ${name}`);
         }
       } catch (error) {
@@ -439,6 +453,21 @@ class ProjectMemoryServer {
     return { content: [{ type: "text", text: `Reindex ${p.slug}: embedded ${done}, failed ${failed} (embeddings ${embeddingConfig().enabled ? "configured" : "not configured"}). ${failed ? "Failures usually mean the embedding model is unavailable right now." : ""}` }] };
   }
 
+  async stats({ root: explicitRoot, top = 10, json = false } = {}) {
+    const root = explicitRoot
+      ? path.resolve(explicitRoot)
+      : (process.env.MEMORY_VAULT_DIR
+          ? path.dirname(process.env.MEMORY_VAULT_DIR)
+          : process.env.JOURNAL_DIR
+            ? path.dirname(process.env.JOURNAL_DIR)
+            : process.env.CHECKPOINT_DIR
+              ? path.dirname(process.env.CHECKPOINT_DIR)
+              : path.join(os.homedir(), ".codex", "memories"));
+    const stats = computeStats({ root, topLimit: top });
+    const text = json ? formatJson(stats) : formatText(stats);
+    return { content: [{ type: "text", text }] };
+  }
+
   async run() {
     const transport = new StdioServerTransport();
     await this.server.connect(transport);