@memorax/memorax-code 0.1.0

package/lib/memorax-code-backend/dist/codex-rollout-turn.js

@@ -0,0 +1,402 @@
+import { readFile } from "node:fs/promises";
+export async function readCodexRolloutTurn(input) {
+    let transcript;
+    try {
+        transcript = await readFile(input.transcriptPath, "utf8");
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: "transcript_unavailable",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    return codexRolloutTurnFromJsonLines(transcript, input);
+}
+export async function readCodexInterruptedRolloutTurn(input) {
+    let transcript;
+    try {
+        transcript = await readFile(input.transcriptPath, "utf8");
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: "transcript_unavailable",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    return codexInterruptedRolloutTurnFromJsonLines(transcript, input);
+}
+export function codexRolloutTurnFromJsonLines(transcript, input) {
+    const scan = scanCodexRolloutTurn(transcript, input.turnId);
+    if (!codexRolloutSessionMatches(scan, input.sessionId)) {
+        return { ok: false, reason: "transcript_session_mismatch" };
+    }
+    if (!scan.targetSeen)
+        return { ok: false, reason: "turn_not_found" };
+    if (!scan.userPrompt)
+        return { ok: false, reason: "user_prompt_missing" };
+    if (!scan.assistantReply)
+        return { ok: false, reason: "assistant_message_missing" };
+    return {
+        ok: true,
+        turn: rolloutTurnFromScan(scan, input, scan.userPrompt, scan.assistantReply),
+    };
+}
+export function codexInterruptedRolloutTurnFromJsonLines(transcript, input) {
+    const scan = scanCodexRolloutTurn(transcript, input.turnId);
+    if (!codexRolloutSessionMatches(scan, input.sessionId)) {
+        return { ok: false, reason: "transcript_session_mismatch" };
+    }
+    if (!scan.targetSeen)
+        return { ok: false, reason: "turn_not_found" };
+    if (!scan.userPrompt)
+        return { ok: false, reason: "user_prompt_missing" };
+    if (!scan.interrupted)
+        return { ok: false, reason: "turn_not_interrupted" };
+    if (scan.rolledBack)
+        return { ok: false, reason: "turn_rolled_back" };
+    const sessionTurnIndex = sessionTurnIndexFromScan(scan, input.turnId);
+    return {
+        ok: true,
+        turn: {
+            ...rolloutTurnFromScan(scan, input, scan.userPrompt, scan.visibleAssistantMessages.join("\n\n")),
+            ...(scan.interruptedAt ? { interruptedAt: scan.interruptedAt } : {}),
+            ...(sessionTurnIndex === undefined ? {} : { sessionTurnIndex }),
+        },
+    };
+}
+function scanCodexRolloutTurn(transcript, targetTurnId) {
+    let authoritySessionId;
+    let ambiguousSessionMetadata = false;
+    let composite = false;
+    let firstNonBlankLineSeen = false;
+    let targetBoundarySeen = false;
+    let activeTurnId;
+    let targetSeen = false;
+    let userPrompt;
+    let assistantReply;
+    const visibleAssistantMessages = [];
+    let interrupted = false;
+    let interruptedAt;
+    let rolledBack = false;
+    let awaitingTargetSuccessor = false;
+    let latestTokenUsage;
+    let targetTokenUsage = emptyTokenUsage();
+    let targetTokenSnapshotSeen = false;
+    let authoritySource;
+    const targetActivityGroups = [];
+    const orderedTurnIds = [];
+    const seenTurnIds = new Set();
+    const turnContextIds = new Set();
+    const userMessageTurnIds = new Set();
+    const observeTurn = (turnId, source) => {
+        activeTurnId = turnId;
+        if (!turnId || seenTurnIds.has(turnId))
+            return;
+        seenTurnIds.add(turnId);
+        orderedTurnIds.push(turnId);
+        if (source === "turn_context")
+            turnContextIds.add(turnId);
+    };
+    for (const line of transcript.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        const authorityHeaderCandidate = !firstNonBlankLineSeen;
+        firstNonBlankLineSeen = true;
+        let record;
+        try {
+            const parsed = JSON.parse(line);
+            if (!isRecord(parsed))
+                continue;
+            record = parsed;
+        }
+        catch {
+            continue;
+        }
+        const payload = isRecord(record.payload) ? record.payload : {};
+        if (record.type === "session_meta") {
+            if (authorityHeaderCandidate) {
+                authoritySessionId = nonBlankString(payload.id);
+                authoritySource = stringValue(payload.source)?.toLowerCase();
+            }
+            else {
+                composite = true;
+                const importedSessionId = nonBlankString(payload.id);
+                if (targetBoundarySeen
+                    || !importedSessionId
+                    || importedSessionId === authoritySessionId) {
+                    ambiguousSessionMetadata = true;
+                }
+            }
+            continue;
+        }
+        if (record.type === "turn_context") {
+            const turnId = stringValue(payload.turn_id) ?? stringValue(payload.turnId);
+            observeTurn(turnId, "turn_context");
+            if (turnId === targetTurnId) {
+                targetSeen = true;
+                targetBoundarySeen = true;
+            }
+            continue;
+        }
+        if (record.type === "response_item") {
+            if (activeTurnId === targetTurnId) {
+                const activities = activityCandidatesFromResponseItem(payload);
+                if (activities.length > 0)
+                    targetActivityGroups.push(activities);
+            }
+            continue;
+        }
+        if (record.type !== "event_msg")
+            continue;
+        const eventType = stringValue(payload.type);
+        if (eventType === "task_started") {
+            const startedTurnId = stringValue(payload.turn_id) ?? stringValue(payload.turnId);
+            if (awaitingTargetSuccessor && startedTurnId && startedTurnId !== targetTurnId) {
+                awaitingTargetSuccessor = false;
+            }
+            observeTurn(startedTurnId, "task_started");
+            if (activeTurnId === targetTurnId) {
+                targetSeen = true;
+                targetBoundarySeen = true;
+            }
+            continue;
+        }
+        if (eventType === "task_complete") {
+            const completedTurnId = stringValue(payload.turn_id) ?? stringValue(payload.turnId);
+            if (completedTurnId === targetTurnId) {
+                targetSeen = true;
+                assistantReply ??= nonBlankString(payload.last_agent_message) ?? nonBlankString(payload.lastAgentMessage);
+            }
+            if (completedTurnId && completedTurnId === activeTurnId)
+                activeTurnId = undefined;
+            continue;
+        }
+        if (eventType === "turn_aborted") {
+            const abortedTurnId = stringValue(payload.turn_id) ?? stringValue(payload.turnId);
+            if (abortedTurnId === targetTurnId) {
+                targetSeen = true;
+                interrupted = stringValue(payload.reason) === "interrupted";
+                interruptedAt = rolloutRecordTimestamp(record, payload);
+                awaitingTargetSuccessor = interrupted;
+            }
+            if (abortedTurnId && abortedTurnId === activeTurnId)
+                activeTurnId = undefined;
+            continue;
+        }
+        if (eventType === "thread_rolled_back") {
+            if (awaitingTargetSuccessor)
+                rolledBack = true;
+            continue;
+        }
+        if (eventType === "token_count") {
+            const snapshot = tokenUsageSnapshot(payload);
+            if (!snapshot)
+                continue;
+            if (activeTurnId === targetTurnId) {
+                targetTokenSnapshotSeen = true;
+                const previous = latestTokenUsage ?? emptyTokenUsage();
+                if (!tokenUsageDecreased(previous, snapshot)) {
+                    targetTokenUsage = addTokenUsageDelta(targetTokenUsage, previous, snapshot);
+                }
+            }
+            latestTokenUsage = snapshot;
+            continue;
+        }
+        if (eventType === "user_message") {
+            if (activeTurnId)
+                userMessageTurnIds.add(activeTurnId);
+            if (activeTurnId !== targetTurnId)
+                continue;
+            userPrompt = nonBlankString(payload.message) ?? userPrompt;
+            continue;
+        }
+        if (activeTurnId !== targetTurnId)
+            continue;
+        if (eventType === "agent_message") {
+            const message = nonBlankString(payload.message);
+            if (!message)
+                continue;
+            if (payload.phase === "commentary" || payload.phase === "final_answer") {
+                visibleAssistantMessages.push(message);
+            }
+            if (payload.phase === "final_answer")
+                assistantReply = message;
+        }
+    }
+    return {
+        authoritySessionId,
+        authoritySource,
+        ambiguousSessionMetadata,
+        composite,
+        targetSeen,
+        userPrompt,
+        assistantReply,
+        visibleAssistantMessages,
+        interrupted,
+        interruptedAt,
+        rolledBack,
+        targetTokenUsage,
+        targetTokenSnapshotSeen,
+        targetActivityGroups,
+        orderedTurnIds,
+        turnContextIds,
+        userMessageTurnIds,
+    };
+}
+function codexRolloutSessionMatches(scan, sessionId) {
+    return scan.authoritySessionId === sessionId && !scan.ambiguousSessionMetadata;
+}
+function sessionTurnIndexFromScan(scan, targetTurnId) {
+    if (scan.composite)
+        return undefined;
+    const countedTurnIds = scan.orderedTurnIds.filter((turnId) => (scan.turnContextIds.has(turnId) || scan.userMessageTurnIds.has(turnId)));
+    const index = countedTurnIds.indexOf(targetTurnId);
+    return index === -1 ? undefined : index + 1;
+}
+function rolloutTurnFromScan(scan, input, userPrompt, assistantReply) {
+    return {
+        sessionId: input.sessionId,
+        turnId: input.turnId,
+        userPrompt,
+        assistantReply,
+        activities: materializeTurnActivities(scan.targetActivityGroups, scan.authoritySource !== "exec"),
+        ...(scan.targetTokenSnapshotSeen && !scan.composite ? { usage: scan.targetTokenUsage } : {}),
+    };
+}
+function rolloutRecordTimestamp(record, payload) {
+    const timestamp = stringValue(record.timestamp);
+    if (timestamp && Number.isFinite(Date.parse(timestamp)))
+        return timestamp;
+    const completedAt = nonNegativeInteger(payload.completed_at ?? payload.completedAt);
+    if (completedAt === undefined)
+        return undefined;
+    const millis = completedAt < 1_000_000_000_000 ? completedAt * 1000 : completedAt;
+    return new Date(millis).toISOString();
+}
+function activityCandidatesFromResponseItem(payload) {
+    const payloadType = stringValue(payload.type);
+    if (payloadType !== "custom_tool_call" && payloadType !== "function_call")
+        return [];
+    const input = toolCallInputText(payload.input ?? payload.arguments);
+    if (!input)
+        return [];
+    const candidates = [];
+    const operationReferencePattern = /[\\/]+plugins[\\/]+cache[\\/]+[^"'`\r\n]*?[\\/]+skills[\\/]+memorax-code[\\/]+references[\\/]+repo-(build|read|update)\.md\b/giu;
+    for (const match of input.matchAll(operationReferencePattern)) {
+        candidates.push({
+            offset: match.index,
+            type: "repo_memory_operation",
+            operation: `repo-${match[1]}`,
+        });
+    }
+    const backgroundJobPattern = /[\\/]+plugins[\\/]+cache[\\/]+[^"'`\r\n]*?[\\/]+hooks[\\/]+repo-memory-job\.mjs\\?["']?\s+start\s+--mode(?:=|\s+)(build|update)\b/giu;
+    for (const match of input.matchAll(backgroundJobPattern)) {
+        candidates.push({
+            offset: match.index,
+            type: "repo_memory_operation",
+            operation: match[1] === "build" ? "repo-build" : "repo-update",
+        });
+    }
+    const memoryCliPattern = /(?:["']?cmd["']?\s*:\s*\\?["'`]|&&|\|\||;)\s*memorax-cli\s+(search|add)\b/giu;
+    for (const match of input.matchAll(memoryCliPattern)) {
+        candidates.push({
+            offset: match.index,
+            type: match[1] === "search" ? "memory_cli_search" : "memory_cli_add",
+        });
+    }
+    return candidates.sort((left, right) => left.offset - right.offset);
+}
+function materializeTurnActivities(groups, includeRepoMemoryOperations) {
+    const activities = [];
+    const seenOperations = new Set();
+    let index = 1;
+    for (const group of groups) {
+        const accepted = group.filter((candidate) => {
+            if (candidate.type !== "repo_memory_operation")
+                return true;
+            if (!includeRepoMemoryOperations || seenOperations.has(candidate.operation))
+                return false;
+            seenOperations.add(candidate.operation);
+            return true;
+        });
+        if (accepted.length === 0)
+            continue;
+        for (const candidate of accepted) {
+            if (candidate.type === "repo_memory_operation") {
+                activities.push({ index, type: candidate.type, operation: candidate.operation });
+            }
+            else {
+                activities.push({ index, type: candidate.type });
+            }
+        }
+        index += 1;
+    }
+    return activities;
+}
+function toolCallInputText(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === undefined)
+        return undefined;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+const TOKEN_USAGE_FIELDS = [
+    "input_tokens",
+    "cached_input_tokens",
+    "cache_write_input_tokens",
+    "output_tokens",
+    "reasoning_output_tokens",
+    "total_tokens",
+];
+function tokenUsageSnapshot(payload) {
+    const info = isRecord(payload.info) ? payload.info : undefined;
+    const usage = info && isRecord(info.total_token_usage) ? info.total_token_usage : undefined;
+    if (!usage)
+        return undefined;
+    const snapshot = emptyTokenUsage();
+    for (const field of TOKEN_USAGE_FIELDS) {
+        const value = nonNegativeInteger(usage[field] ?? (field === "cache_write_input_tokens" ? 0 : undefined));
+        if (value === undefined)
+            return undefined;
+        snapshot[field] = value;
+    }
+    return snapshot;
+}
+function addTokenUsageDelta(total, previous, current) {
+    const next = { ...total };
+    for (const field of TOKEN_USAGE_FIELDS)
+        next[field] += current[field] - previous[field];
+    return next;
+}
+function tokenUsageDecreased(previous, current) {
+    return TOKEN_USAGE_FIELDS.some((field) => current[field] < previous[field]);
+}
+function emptyTokenUsage() {
+    return {
+        input_tokens: 0,
+        cached_input_tokens: 0,
+        cache_write_input_tokens: 0,
+        output_tokens: 0,
+        reasoning_output_tokens: 0,
+        total_tokens: 0,
+    };
+}
+function nonNegativeInteger(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : undefined;
+}
+function nonBlankString(value) {
+    return typeof value === "string" && value.trim() ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}

package/lib/memorax-code-backend/dist/codex-session-turn-index.js

@@ -0,0 +1,88 @@
+import { readFile } from "node:fs/promises";
+export async function readCodexSessionTurnIndex(input) {
+    let transcript;
+    try {
+        transcript = await readFile(input.transcriptPath, "utf8");
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: "transcript_unavailable",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    return codexSessionTurnIndexFromJsonLines(transcript, input);
+}
+export function codexSessionTurnIndexFromJsonLines(transcript, input) {
+    const sessionIds = new Set();
+    const orderedTurnIds = [];
+    const seenTurnIds = new Set();
+    const turnContextIds = new Set();
+    const userMessageTurnIds = new Set();
+    let activeTurnId;
+    const observeTurn = (turnId, source) => {
+        activeTurnId = turnId;
+        if (!turnId || seenTurnIds.has(turnId))
+            return;
+        seenTurnIds.add(turnId);
+        orderedTurnIds.push(turnId);
+        if (source === "turn_context")
+            turnContextIds.add(turnId);
+    };
+    for (const line of transcript.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        let record;
+        try {
+            const parsed = JSON.parse(line);
+            if (!isRecord(parsed))
+                continue;
+            record = parsed;
+        }
+        catch {
+            continue;
+        }
+        const payload = isRecord(record.payload) ? record.payload : {};
+        if (record.type === "session_meta") {
+            const sessionId = stringValue(payload.id) ?? stringValue(payload.session_id);
+            if (sessionId)
+                sessionIds.add(sessionId);
+            continue;
+        }
+        if (record.type === "turn_context") {
+            const turnId = stringValue(payload.turn_id) ?? stringValue(payload.turnId);
+            observeTurn(turnId, "turn_context");
+            continue;
+        }
+        if (record.type !== "event_msg")
+            continue;
+        const eventType = stringValue(payload.type);
+        if (eventType === "task_started") {
+            observeTurn(stringValue(payload.turn_id) ?? stringValue(payload.turnId), "task_started");
+            continue;
+        }
+        if (eventType === "user_message" && activeTurnId) {
+            userMessageTurnIds.add(activeTurnId);
+            continue;
+        }
+        if (eventType === "task_complete") {
+            const completedTurnId = stringValue(payload.turn_id) ?? stringValue(payload.turnId);
+            if (completedTurnId && completedTurnId === activeTurnId)
+                activeTurnId = undefined;
+        }
+    }
+    if (sessionIds.size !== 1 || !sessionIds.has(input.sessionId)) {
+        return { ok: false, reason: "transcript_session_mismatch" };
+    }
+    const countedTurnIds = orderedTurnIds.filter((turnId) => (turnContextIds.has(turnId) || userMessageTurnIds.has(turnId)));
+    const sessionTurnIndex = countedTurnIds.indexOf(input.turnId) + 1;
+    if (sessionTurnIndex === 0)
+        return { ok: false, reason: "turn_not_found" };
+    return { ok: true, sessionTurnIndex };
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}

package/lib/memorax-code-backend/dist/codex-workspace-links.js

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+export function resolveCodexWorkspaceRoot(input) {
+    const cwd = cwdFromWorkspaceRegistry(input.sessionHome, input.sessionKey);
+    return cwd ? safeRealpathDirectory(cwd) : undefined;
+}
+function sanitizePathSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 120) || "branch";
+}
+function cwdFromWorkspaceRegistry(sessionHome, sessionKey) {
+    if (!sessionKey)
+        return undefined;
+    const registry = readJsonFile(join(sessionHome, "adapters", "codex", "workspaces.json"));
+    const sessions = registry?.sessions;
+    if (!sessions || typeof sessions !== "object")
+        return undefined;
+    for (const key of workspaceLookupKeys(sessionKey)) {
+        const cwd = objectString(sessions[key]?.cwd);
+        if (cwd && isAbsolute(cwd))
+            return cwd;
+    }
+    return undefined;
+}
+function workspaceLookupKeys(sessionKey) {
+    const keys = new Set();
+    keys.add(sessionKey);
+    if (sessionKey.startsWith("codex_"))
+        keys.add(sessionKey.slice("codex_".length));
+    else
+        keys.add(`codex_${sessionKey}`);
+    keys.add(sanitizePathSegment(sessionKey));
+    return [...keys];
+}
+function safeRealpathDirectory(path) {
+    try {
+        const resolved = realpathSync(resolve(path));
+        return statSync(resolved).isDirectory() ? resolved : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readJsonFile(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function objectString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/lib/memorax-code-backend/dist/debug-log.js

@@ -0,0 +1,21 @@
+import { backendEnv } from "./backend-env.js";
+export function backendDebugEnabled() {
+    const value = backendEnv("DEBUG_REQUESTS");
+    return value === "1" || value === "true" || value === "yes";
+}
+export function backendDebug(message, fields = {}) {
+    if (!backendDebugEnabled())
+        return;
+    const suffix = Object.entries(fields)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => `${key}=${formatValue(value)}`)
+        .join(" ");
+    console.error(`[memorax-code-backend:debug] ${message}${suffix ? ` ${suffix}` : ""}`);
+}
+function formatValue(value) {
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    return JSON.stringify(value);
+}

package/lib/memorax-code-backend/dist/entrypoint.js

@@ -0,0 +1,14 @@
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+export function isMainEntrypoint(importMetaUrl, argv = process.argv) {
+    const script = argv[1];
+    if (!script)
+        return false;
+    const modulePath = fileURLToPath(importMetaUrl);
+    try {
+        return realpathSync(modulePath) === realpathSync(script);
+    }
+    catch {
+        return modulePath === script;
+    }
+}