@echomem/mcp 1.4.7 → 1.4.9

package/dist/codex-session-files.js

@@ -0,0 +1,283 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveCodexSessionRoots, resolveReadableDirectory, } from "./local-data-paths.js";
+const ROLLOUT_FILE_RE = /^rollout-.*\.jsonl$/;
+const UUID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+const FIRST_LINE_CHUNK_BYTES = 64 * 1024;
+const MAX_FIRST_LINE_BYTES = 2 * 1024 * 1024;
+function initialJsonLines(file) {
+    const fd = fs.openSync(file, "r");
+    try {
+        const chunk = Buffer.allocUnsafe(FIRST_LINE_CHUNK_BYTES);
+        const buffers = [];
+        let total = 0;
+        while (total < MAX_FIRST_LINE_BYTES) {
+            const remaining = Math.min(chunk.length, MAX_FIRST_LINE_BYTES - total);
+            const bytesRead = fs.readSync(fd, chunk, 0, remaining, null);
+            if (bytesRead <= 0)
+                break;
+            const piece = Buffer.from(chunk.subarray(0, bytesRead));
+            buffers.push(piece);
+            total += bytesRead;
+        }
+        if (!buffers.length)
+            return [];
+        return Buffer.concat(buffers).toString("utf8").split(/\r?\n/).filter(Boolean);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function normalizedSessionId(value) {
+    const trimmed = value.trim();
+    return new RegExp(`^${UUID_RE.source}$`, "i").test(trimmed) ? trimmed.toLowerCase() : trimmed;
+}
+function metadataFromFile(file) {
+    try {
+        for (const line of initialJsonLines(file)) {
+            let row;
+            try {
+                row = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!isRecord(row) || row.type !== "session_meta" || !isRecord(row.payload))
+                continue;
+            const payload = row.payload;
+            const rawId = typeof payload.id === "string" ? normalizedSessionId(payload.id) : "";
+            // payload.timestamp is the semantic session launch time. The row timestamp is only when the
+            // first metadata event was persisted and can trail launch by several minutes.
+            const rawTimestamp = typeof payload.timestamp === "string"
+                ? payload.timestamp
+                : typeof row.timestamp === "string"
+                    ? row.timestamp
+                    : "";
+            const timestamp = rawTimestamp ? Date.parse(rawTimestamp) : NaN;
+            const source = payload.source;
+            const isSubagent = isRecord(source) && Object.hasOwn(source, "subagent");
+            const hasParent = typeof payload.parent_thread_id === "string" && payload.parent_thread_id.length > 0;
+            return {
+                id: rawId || null,
+                startedAtMs: Number.isFinite(timestamp) ? timestamp : null,
+                userInitiated: !isSubagent && !hasParent,
+            };
+        }
+        return { id: null, startedAtMs: null, userInitiated: null };
+    }
+    catch {
+        return { id: null, startedAtMs: null, userInitiated: null };
+    }
+}
+function filenameUuid(file) {
+    return path.basename(file).match(UUID_RE)?.[1]?.toLowerCase() ?? null;
+}
+function filenameTimestamp(file) {
+    const match = path.basename(file).match(/rollout-(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})/);
+    if (!match)
+        return null;
+    // Codex rollout filenames encode the originating machine's local wall-clock time, not UTC.
+    // This process is reading that same local profile, so parse without a trailing Z and let DST apply.
+    const parsed = Date.parse(`${match[1]}T${match[2]}:${match[3]}:${match[4]}`);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function lastEventTimestamp(file, size) {
+    const bytes = Math.min(size, MAX_FIRST_LINE_BYTES);
+    if (bytes <= 0)
+        return null;
+    let fd = null;
+    try {
+        fd = fs.openSync(file, "r");
+        const buffer = Buffer.allocUnsafe(bytes);
+        const offset = Math.max(0, size - bytes);
+        const read = fs.readSync(fd, buffer, 0, bytes, offset);
+        const lines = buffer.toString("utf8", 0, read).split(/\r?\n/);
+        // The first line can be a partial tail when offset > 0; never trust it in that case.
+        const firstComplete = offset > 0 ? 1 : 0;
+        for (let index = lines.length - 1; index >= firstComplete; index -= 1) {
+            const line = lines[index]?.trim();
+            if (!line)
+                continue;
+            try {
+                const row = JSON.parse(line);
+                if (!isRecord(row) || typeof row.timestamp !== "string")
+                    continue;
+                const timestamp = Date.parse(row.timestamp);
+                if (Number.isFinite(timestamp))
+                    return timestamp;
+            }
+            catch {
+                /* keep looking for the last complete timestamped JSONL event */
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd != null)
+            fs.closeSync(fd);
+    }
+    return null;
+}
+function regularRolloutFiles(root) {
+    const files = [];
+    const visit = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const candidate = path.join(dir, entry.name);
+            if (entry.isSymbolicLink())
+                continue;
+            if (entry.isDirectory()) {
+                visit(candidate);
+                continue;
+            }
+            if (entry.isFile() && ROLLOUT_FILE_RE.test(entry.name))
+                files.push(candidate);
+        }
+    };
+    visit(root);
+    return files.sort();
+}
+function normalizedRoots(opts) {
+    const requested = opts.roots ? [...opts.roots] : resolveCodexSessionRoots(opts);
+    const includeArchived = opts.includeArchived !== false;
+    const roots = [];
+    const seen = new Set();
+    for (const candidate of requested.sort((left, right) => ((left.kind === "active" ? 0 : 1) - (right.kind === "active" ? 0 : 1)
+        || left.priority - right.priority
+        || left.path.localeCompare(right.path)))) {
+        if (!includeArchived && candidate.kind === "archived")
+            continue;
+        const resolved = resolveReadableDirectory(candidate.path);
+        if (!resolved || seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        roots.push({ ...candidate, path: resolved });
+    }
+    return roots;
+}
+function candidateFor(file, root) {
+    let real;
+    let stat;
+    try {
+        const lstat = fs.lstatSync(file);
+        if (!lstat.isFile() || lstat.isSymbolicLink())
+            return null;
+        fs.accessSync(file, fs.constants.R_OK);
+        real = fs.realpathSync(file);
+        stat = fs.statSync(real);
+        if (!stat.isFile())
+            return null;
+    }
+    catch {
+        return null;
+    }
+    const metadata = metadataFromFile(real);
+    const uuid = filenameUuid(real);
+    const identitySource = metadata.id ? "metadata" : uuid ? "filename" : "path";
+    const identity = metadata.id || uuid || real;
+    return {
+        path: real,
+        rootKind: root.kind,
+        sessionKey: identitySource === "path" ? `path:${identity}` : `session:${identity}`,
+        identitySource,
+        identityRank: identitySource === "metadata" ? 0 : identitySource === "filename" ? 1 : 2,
+        startedAtMs: metadata.startedAtMs ?? filenameTimestamp(real),
+        lastEventAtMs: lastEventTimestamp(real, stat.size),
+        userInitiated: metadata.userInitiated,
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+    };
+}
+function candidateOrder(left, right) {
+    const leftRoot = left.rootKind === "active" ? 0 : 1;
+    const rightRoot = right.rootKind === "active" ? 0 : 1;
+    return left.identityRank - right.identityRank
+        || (right.lastEventAtMs ?? Number.NEGATIVE_INFINITY) - (left.lastEventAtMs ?? Number.NEGATIVE_INFINITY)
+        || right.size - left.size
+        || leftRoot - rightRoot
+        || right.mtimeMs - left.mtimeMs
+        || left.path.localeCompare(right.path);
+}
+function chronologicalOrder(left, right) {
+    if (left.startedAtMs != null && right.startedAtMs != null) {
+        if (left.startedAtMs !== right.startedAtMs)
+            return left.startedAtMs - right.startedAtMs;
+        return left.sessionKey.localeCompare(right.sessionKey) || left.path.localeCompare(right.path);
+    }
+    if (left.startedAtMs != null)
+        return -1;
+    if (right.startedAtMs != null)
+        return 1;
+    return left.sessionKey.localeCompare(right.sessionKey) || left.path.localeCompare(right.path);
+}
+/**
+ * Discover one deterministic, de-duplicated file per Codex session across active and archived roots.
+ * JSONL files are never merged. A duplicate keeps the strongest, latest, most complete candidate and
+ * is surfaced in diagnostics; active vs archived is only a tie-break after semantic completeness.
+ */
+export function discoverCodexSessionFiles(opts = {}) {
+    const roots = normalizedRoots(opts);
+    const diagnostics = {
+        scannedFiles: 0,
+        skippedUnreadableFiles: 0,
+        filenameIdentityFallbacks: 0,
+        pathIdentityFallbacks: 0,
+        unclassifiedSessions: 0,
+        conflicts: [],
+    };
+    const grouped = new Map();
+    for (const root of roots) {
+        for (const file of regularRolloutFiles(root.path)) {
+            diagnostics.scannedFiles += 1;
+            const candidate = candidateFor(file, root);
+            if (!candidate) {
+                diagnostics.skippedUnreadableFiles += 1;
+                continue;
+            }
+            if (candidate.identitySource === "filename")
+                diagnostics.filenameIdentityFallbacks += 1;
+            if (candidate.identitySource === "path")
+                diagnostics.pathIdentityFallbacks += 1;
+            if (candidate.userInitiated == null)
+                diagnostics.unclassifiedSessions += 1;
+            const list = grouped.get(candidate.sessionKey) || [];
+            list.push(candidate);
+            grouped.set(candidate.sessionKey, list);
+        }
+    }
+    const files = [];
+    for (const [sessionKey, candidates] of grouped) {
+        candidates.sort(candidateOrder);
+        const [kept, ...discarded] = candidates;
+        if (!kept)
+            continue;
+        if (!opts.userInitiatedOnly || kept.userInitiated === true) {
+            const { identityRank: _identityRank, ...file } = kept;
+            files.push(file);
+        }
+        for (const duplicate of discarded) {
+            diagnostics.conflicts.push({
+                sessionKey,
+                keptPath: kept.path,
+                keptRootKind: kept.rootKind,
+                discardedPath: duplicate.path,
+                discardedRootKind: duplicate.rootKind,
+            });
+        }
+    }
+    files.sort(chronologicalOrder);
+    diagnostics.conflicts.sort((left, right) => left.sessionKey.localeCompare(right.sessionKey)
+        || left.discardedPath.localeCompare(right.discardedPath));
+    return { roots, files, diagnostics };
+}

package/dist/codex-sync.js

@@ -1,10 +1,10 @@
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { createHash } from "node:crypto";
 import axios from "axios";
 import { KeyStore } from "./keystore.js";
+import { resolveCodexSessionsDir } from "./local-data-paths.js";
 const API_BASE_URL = (process.env.ECHO_API_BASE_URL || "https://echo-mem-chrome.vercel.app").replace(/\/$/, "");
 const DEFAULT_DAYS = 7;
 const DEFAULT_LIMIT = 50;
@@ -427,7 +427,12 @@ export async function syncCodexUsage(argv) {
     const days = flags.all ? Number.POSITIVE_INFINITY : Number(flags.days ?? DEFAULT_DAYS);
     const limit = Number(flags.limit ?? DEFAULT_LIMIT);
     const dryRun = flags["dry-run"] === true;
-    const root = typeof flags.root === "string" ? flags.root : path.join(os.homedir(), ".codex", "sessions");
+    const root = typeof flags.root === "string" ? flags.root : resolveCodexSessionsDir();
+    if (!root) {
+        console.error("No readable Codex sessions directory was found. Check CODEX_HOME or pass --root explicitly.");
+        process.exitCode = 1;
+        return;
+    }
     const token = new KeyStore().getToken();
     if (!dryRun && !token) {
         console.error("Not logged in. Run `echomem-mcp login` first, or re-run with --dry-run.");

package/dist/context-analysis/canonical-golden.js

@@ -0,0 +1,47 @@
+import { buildVendoredCanonicalReport } from "./vendored-canonical.js";
+export const CANONICAL_PROBLEM_COUNT = 13;
+export const CANONICAL_PROBLEMS = [
+    { id: "P01", name: "Outdated Images & Screenshots" },
+    { id: "P02", name: "Ignored User Instructions" },
+    { id: "P03", name: "Old Files" },
+    { id: "P04", name: "Repeated Setup After Compaction" },
+    { id: "P05", name: "Premature Completion Fixes" },
+    { id: "P06", name: "Session Re-heat" },
+    { id: "P07", name: "Failed Turn Leftovers" },
+    { id: "P08", name: "Repeated Git Check Logs" },
+    { id: "P09", name: "Repeated Fix Attempts" },
+    { id: "P10", name: "Repeated Search" },
+    { id: "P11", name: "Visual Debug Logs" },
+    { id: "P12", name: "Tool Call Logs" },
+    { id: "P13", name: "Agent's Reasoning Notes" },
+];
+export function analyzeCanonicalCodexSession(options) {
+    void options.workspacePath;
+    return buildCanonicalGoldenReport({ sources: ["codex"], codexSessionPaths: [options.sessionPath] });
+}
+export function analyzeCanonicalClaudeSession(options) {
+    void options.workspacePath;
+    return buildCanonicalGoldenReport({ sources: ["claude-code"], claudeSessionPaths: [options.sessionPath] });
+}
+export async function buildCanonicalGoldenReport(opts) {
+    const scoringMode = "episode-outcome";
+    const report = await buildVendoredCanonicalReport({
+        limitFiles: opts?.limitFiles,
+        sources: opts?.sources,
+        codexSessionPaths: opts?.codexSessionPaths,
+        claudeSessionPaths: opts?.claudeSessionPaths,
+        strictSessionErrors: opts?.strictSessionErrors,
+        sessionPaths: opts?.sessionPaths,
+        onProgress: opts?.onProgress,
+    });
+    return {
+        ...report,
+        canonical: {
+            scoringMode,
+            algorithm: "provider-native-context-golden-standard-v3",
+            source: "context-golden-standard",
+            bucketContract: ["keep_oh", "keep_prod", "opt_dup", "opt_refind", "opt_dead"],
+            wasteRule: "raw-residue-with-p-attribution",
+        },
+    };
+}