@memorax/memorax-code 0.1.0

package/lib/memorax-code-backend/dist/memory-writeback-task-projection.js

@@ -0,0 +1,377 @@
+import { randomUUID } from "node:crypto";
+import { readIncrementalJsonlProjection, } from "./incremental-jsonl-projection.js";
+import { memoryProjectFromUnknown, resolveMemoryProject, } from "./memory-project.js";
+import { clientTracePaths } from "./trace-config.js";
+import { isTraceClient, } from "./trace-context.js";
+const LIVE_TASK_CAPACITY = 1_024;
+const PENDING_WRITEBACK_STATUSES = new Set([
+    "accepted",
+    "processing",
+    "queued",
+    "pending",
+    "unknown",
+]);
+export function createMemoryWritebackTaskProjection(options) {
+    const client = options.client;
+    const liveTasks = new Map();
+    return {
+        client,
+        observabilityHook: {
+            recordEvent(event) {
+                const projected = projectLiveWritebackTask(event);
+                if (!projected || projected.client !== client)
+                    return;
+                liveTasks.set(memoryWritebackTaskEventKey(projected), projected);
+                while (liveTasks.size > LIVE_TASK_CAPACITY) {
+                    const oldest = liveTasks.keys().next().value;
+                    if (typeof oldest !== "string")
+                        break;
+                    liveTasks.delete(oldest);
+                }
+            },
+        },
+        async listPending() {
+            const historical = await readMemoryWritebackTaskHistory(options.memoraxCodeHome, client);
+            const merged = new Map();
+            for (const record of [...historical, ...liveTasks.values()]) {
+                merged.set(memoryWritebackTaskEventKey(record), record);
+            }
+            return pendingMemoryWritebackTasks([...merged.values()].sort(compareMemoryWritebackTaskRecords)).filter((task) => (task.client === client && Boolean(task.sessionId)));
+        },
+        clear() {
+            liveTasks.clear();
+        },
+    };
+}
+export function projectMemoryWritebackTasks(records) {
+    const statusByOriginalEvent = new Map();
+    const statusByTask = new Map();
+    for (const record of records) {
+        if (record.kind !== "status")
+            continue;
+        if (record.originalEventId) {
+            statusByOriginalEvent.set(memoryWritebackTaskEventKey({
+                ...record,
+                eventId: record.originalEventId,
+            }), record);
+        }
+        const key = writebackTaskKey(record);
+        if (key)
+            statusByTask.set(key, record);
+    }
+    return records.flatMap((record) => {
+        if (record.kind !== "task")
+            return [];
+        const key = writebackTaskKey(record);
+        const explicitStatus = statusByOriginalEvent.get(memoryWritebackTaskEventKey(record));
+        const status = explicitStatus && (!explicitStatus.taskId || explicitStatus.taskId === record.taskId)
+            ? explicitStatus
+            : key
+                ? statusByTask.get(key)
+                : undefined;
+        return [{
+                eventId: record.eventId,
+                timestamp: record.timestamp,
+                ...(record.client ? { client: record.client } : {}),
+                ...(record.sessionId ? { sessionId: record.sessionId } : {}),
+                ...(record.turnId ? { turnId: record.turnId } : {}),
+                ...(record.memoryProject ? { memoryProject: record.memoryProject } : {}),
+                accepted: record.ok,
+                taskId: record.taskId,
+                completion: status?.completion ?? completeMemoryWritebackTask({
+                    status: record.status,
+                }),
+                ...(status ? { statusEventId: status.eventId } : {}),
+            }];
+    });
+}
+export function memoryWritebackTaskEventKey(recordValue) {
+    return JSON.stringify([
+        recordValue.client ?? "",
+        recordValue.sessionId ?? "",
+        recordValue.eventId,
+    ]);
+}
+export function pendingMemoryWritebackTasks(records) {
+    return projectMemoryWritebackTasks(records)
+        .filter((task) => (task.accepted
+        && task.completion.ok
+        && task.completion.outcome === "pending"));
+}
+export function completeMemoryWritebackTask(input) {
+    const status = input.status.trim().toLowerCase();
+    const savedMemories = uniqueStrings([
+        ...stringArray(input.savedMemories),
+        ...memoryTexts(input.memory),
+    ]);
+    const savedMemoryIds = uniqueStrings([
+        ...stringArray(input.savedMemoryIds),
+        ...memoryAddIds(input.memory),
+    ]);
+    const reportedMemoryCount = nonNegativeInteger(input.savedMemoryCount)
+        ?? memorySavedCount(input.memory);
+    const savedMemoryCount = reportedMemoryCount
+        ?? (savedMemoryIds.length > 0 ? savedMemoryIds.length : savedMemories.length);
+    const outcome = memoryWritebackTaskOutcome(input.outcome)
+        ?? memoryWritebackTaskOutcomeForStatus(status, {
+            memoryKnown: input.memoryKnown === true,
+            savedMemoryCount,
+        });
+    return {
+        status,
+        outcome,
+        ok: outcome !== "failed",
+        ...(savedMemoryCount > 0 ? { savedMemoryCount } : {}),
+        ...(savedMemoryIds.length > 0 ? { savedMemoryIds } : {}),
+        ...(savedMemories.length > 0 ? { savedMemories } : {}),
+        ...(input.error ? { error: input.error.slice(0, 2_000) } : {}),
+    };
+}
+export function memoryWritebackTaskOutcome(value) {
+    return value === "pending"
+        || value === "saved"
+        || value === "skipped"
+        || value === "failed"
+        || value === "completed"
+        ? value
+        : undefined;
+}
+export function memoryWritebackTaskOutcomeForStatus(status, result = {}) {
+    const normalized = status.trim().toLowerCase();
+    if (PENDING_WRITEBACK_STATUSES.has(normalized))
+        return "pending";
+    if (["failed", "error", "cancelled", "canceled"].includes(normalized))
+        return "failed";
+    if (normalized === "success" || normalized === "completed") {
+        if ((result.savedMemoryCount ?? 0) > 0)
+            return "saved";
+        if (result.memoryKnown)
+            return "skipped";
+        return "completed";
+    }
+    return "completed";
+}
+export function memoryText(value) {
+    const item = record(value);
+    if (!item)
+        return "";
+    for (const key of ["memory", "summary", "content", "text"]) {
+        const text = stringValue(item[key]);
+        if (text)
+            return text;
+    }
+    return "";
+}
+export function stringArray(value) {
+    return Array.isArray(value)
+        ? value.map(stringValue).filter(Boolean).slice(0, 1_000)
+        : [];
+}
+export function nonNegativeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+        ? value
+        : undefined;
+}
+async function readMemoryWritebackTaskHistory(memoraxCodeHome, client) {
+    return await readIncrementalJsonlProjection({
+        namespace: `memory-writeback-task:${client}`,
+        root: clientTracePaths(client, memoraxCodeHome).sessionsRoot,
+        filename: "events.jsonl",
+        identity: client,
+        project(value, sessionDir) {
+            const projected = projectTraceWritebackTask(value, sessionDir, client);
+            return projected ? { value: projected } : undefined;
+        },
+        compare: compareMemoryWritebackTaskRecords,
+    });
+}
+function projectLiveWritebackTask(event) {
+    if (event.operation !== "writeback")
+        return undefined;
+    const state = writebackState(event.response);
+    if (!state.taskId || !state.status)
+        return undefined;
+    const context = event.traceContext;
+    return {
+        kind: "task",
+        eventId: event.eventId ?? `memory-observability-${randomUUID()}`,
+        timestamp: new Date().toISOString(),
+        ...(context?.client ? { client: context.client } : {}),
+        ...(safeIdentifier(context?.sessionId) ? { sessionId: safeIdentifier(context?.sessionId) } : {}),
+        ...(safeIdentifier(context?.turnId) ? { turnId: safeIdentifier(context?.turnId) } : {}),
+        ...(context?.memoryProject ? { memoryProject: context.memoryProject } : {}),
+        ok: event.ok,
+        taskId: state.taskId,
+        status: state.status,
+    };
+}
+function projectTraceWritebackTask(value, sessionDir, expectedClient) {
+    const raw = record(value);
+    if (!raw)
+        return undefined;
+    const type = stringValue(raw.type);
+    if (type !== "memory_writeback"
+        && type !== "memory_cli_add"
+        && type !== "memory_writeback_status") {
+        return undefined;
+    }
+    const trace = record(raw.trace);
+    const rawClient = stringValue(trace?.client);
+    const client = isTraceClient(rawClient) ? rawClient : undefined;
+    if (client !== expectedClient)
+        return undefined;
+    const sessionId = safeIdentifier(stringValue(trace?.session_id)
+        || stringValue(trace?.sessionId)
+        || sessionDir);
+    const turnId = safeIdentifier(stringValue(trace?.turn_id) || stringValue(trace?.turnId));
+    const request = record(raw.request);
+    const memoryProject = memoryProjectFromUnknown(trace?.memory_project)
+        ?? memoryProjectFromUnknown(trace?.memoryProject)
+        ?? resolveMemoryProject(stringValue(trace?.cwd) || stringValue(request?.cwd));
+    const timestamp = validTimestamp(raw.timestamp);
+    const eventId = stringValue(raw.event_id)
+        || `${sessionId || "unscoped"}:${type}:${timestamp}`;
+    const response = record(raw.response);
+    const state = writebackState(response);
+    if (type === "memory_writeback_status") {
+        const taskId = stringValue(request?.task_id)
+            || stringValue(request?.taskId)
+            || state.taskId;
+        const status = state.status;
+        if (!status)
+            return undefined;
+        const originalEventId = stringValue(request?.original_event_id ?? request?.originalEventId);
+        if (!originalEventId && (!taskId || !sessionId))
+            return undefined;
+        return {
+            kind: "status",
+            eventId,
+            timestamp,
+            client,
+            ...(sessionId ? { sessionId } : {}),
+            ...(turnId ? { turnId } : {}),
+            ...(memoryProject ? { memoryProject } : {}),
+            ...(taskId ? { taskId } : {}),
+            ...(originalEventId ? { originalEventId } : {}),
+            completion: completeMemoryWritebackTask({
+                status,
+                outcome: response?.outcome,
+                savedMemoryCount: response?.savedMemoryCount ?? response?.saved_memory_count,
+                savedMemoryIds: response?.savedMemoryIds ?? response?.saved_memory_ids,
+                savedMemories: response?.savedMemories ?? response?.saved_memories,
+                error: stringValue(raw.error) || null,
+            }),
+        };
+    }
+    if (!state.taskId || !state.status)
+        return undefined;
+    return {
+        kind: "task",
+        eventId,
+        timestamp,
+        client,
+        ...(sessionId ? { sessionId } : {}),
+        ...(turnId ? { turnId } : {}),
+        ...(memoryProject ? { memoryProject } : {}),
+        ok: raw.ok !== false,
+        taskId: state.taskId,
+        status: state.status,
+    };
+}
+function writebackState(value) {
+    const response = record(value);
+    const raw = record(response?.raw) ?? response;
+    const data = record(raw?.data);
+    return {
+        taskId: stringValue(data?.task_id)
+            || stringValue(response?.taskId)
+            || stringValue(response?.task_id),
+        status: (stringValue(data?.status)
+            || stringValue(response?.status)
+            || stringValue(response?.addStatus)).toLowerCase(),
+    };
+}
+function writebackTaskKey(recordValue) {
+    return recordValue.sessionId && recordValue.taskId
+        ? JSON.stringify([recordValue.client ?? "", recordValue.sessionId, recordValue.taskId])
+        : undefined;
+}
+function compareMemoryWritebackTaskRecords(left, right) {
+    const leftTime = Date.parse(left.timestamp);
+    const rightTime = Date.parse(right.timestamp);
+    const leftOrder = Number.isFinite(leftTime) ? leftTime : 0;
+    const rightOrder = Number.isFinite(rightTime) ? rightTime : 0;
+    return leftOrder - rightOrder || left.eventId.localeCompare(right.eventId);
+}
+function validTimestamp(value) {
+    const timestamp = stringValue(value);
+    return timestamp && Number.isFinite(Date.parse(timestamp))
+        ? timestamp
+        : new Date().toISOString();
+}
+function safeIdentifier(value) {
+    const candidate = stringValue(value);
+    if (!candidate || candidate.length > 512)
+        return "";
+    if (/[\u0000-\u001f\u007f\\/]/.test(candidate))
+        return "";
+    return candidate;
+}
+function memoryTexts(value) {
+    const output = [];
+    const visit = (item, depth) => {
+        if (depth > 4)
+            return;
+        if (typeof item === "string") {
+            const text = item.trim();
+            if (text)
+                output.push(text);
+            return;
+        }
+        if (Array.isArray(item)) {
+            for (const entry of item)
+                visit(entry, depth + 1);
+            return;
+        }
+        const wrapped = record(item);
+        if (!wrapped)
+            return;
+        const text = memoryText(item);
+        if (text)
+            output.push(text);
+        for (const key of ["items", "memories", "facts", "samples"]) {
+            visit(wrapped[key], depth + 1);
+        }
+    };
+    visit(value, 0);
+    return uniqueStrings(output);
+}
+function memorySavedCount(value) {
+    const wrapped = record(value);
+    if (!wrapped)
+        return undefined;
+    const total = nonNegativeInteger(wrapped.total);
+    if (total !== undefined)
+        return total;
+    return nonNegativeInteger(record(wrapped.operations)?.ADD);
+}
+function memoryAddIds(value) {
+    const wrapped = record(value);
+    const events = Array.isArray(wrapped?.events) ? wrapped.events : [];
+    return uniqueStrings(events
+        .map(record)
+        .filter((event) => stringValue(event?.event).toUpperCase() === "ADD")
+        .map((event) => stringValue(event?.memory_id) || stringValue(event?.id))
+        .filter(Boolean));
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value.trim() : "";
+}

package/lib/memorax-code-backend/dist/proxy-env.js

@@ -0,0 +1,54 @@
+const LOOPBACK_NO_PROXY_HOSTS = ["127.0.0.1", "localhost", "::1"];
+export function withLoopbackProxyBypass(env = process.env, backendUrl) {
+    const hosts = loopbackProxyBypassHosts(backendUrl);
+    if (hosts.length === 0)
+        return { ...env };
+    const entries = [];
+    const seen = new Set();
+    for (const value of [env.NO_PROXY, env.no_proxy]) {
+        for (const entry of splitNoProxy(value))
+            addEntry(entries, seen, entry);
+    }
+    for (const host of hosts)
+        addEntry(entries, seen, host);
+    const merged = entries.join(",");
+    return {
+        ...env,
+        NO_PROXY: merged,
+        no_proxy: merged,
+    };
+}
+function loopbackProxyBypassHosts(backendUrl) {
+    if (!backendUrl)
+        return [...LOOPBACK_NO_PROXY_HOSTS];
+    try {
+        const host = normalizeHost(new URL(backendUrl).hostname);
+        if (!isLoopbackHost(host))
+            return [];
+        return [...new Set([...LOOPBACK_NO_PROXY_HOSTS, host])];
+    }
+    catch {
+        return [...LOOPBACK_NO_PROXY_HOSTS];
+    }
+}
+function splitNoProxy(value) {
+    if (typeof value !== "string")
+        return [];
+    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function addEntry(entries, seen, entry) {
+    const key = entry.toLowerCase();
+    if (seen.has(key))
+        return;
+    seen.add(key);
+    entries.push(entry);
+}
+function normalizeHost(value) {
+    return value.replace(/^\[/, "").replace(/\]$/, "").toLowerCase();
+}
+function isLoopbackHost(host) {
+    return host === "localhost"
+        || host === "::1"
+        || host === "0:0:0:0:0:0:0:1"
+        || /^127(?:\.\d{1,3}){3}$/.test(host);
+}

package/lib/memorax-code-backend/dist/repo-memory-readiness.js

@@ -0,0 +1,188 @@
+import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+import { memoryProjectRoot } from "./memory-project.js";
+const execFileAsync = promisify(execFile);
+const STABLE_READINESS_CACHE_TTL_MS = 30_000;
+const PREPARING_READINESS_CACHE_TTL_MS = 5_000;
+const UNRESOLVED_READINESS_CACHE_TTL_MS = 10_000;
+const READINESS_CACHE_CAPACITY = 256;
+export const REPO_MEMORY_READINESS_MAX_CONCURRENT_VALIDATIONS = 4;
+const readinessCache = new Map();
+const readinessInFlight = new Map();
+const dependencyScopes = new WeakMap();
+const validationWaiters = [];
+let nextDependencyScope = 1;
+let activeBundleValidations = 0;
+const DEFAULT_READINESS_DEPENDENCIES = Object.freeze({});
+export async function repoMemoryReadinessForProject(projectId, memoraxCodeHome, dependencies = DEFAULT_READINESS_DEPENDENCIES) {
+    const cacheKey = readinessCacheKey(projectId, memoraxCodeHome, dependencies);
+    const cached = readCachedReadiness(cacheKey);
+    if (cached)
+        return cached;
+    const pending = readinessInFlight.get(cacheKey);
+    if (pending)
+        return pending;
+    const request = resolveRepoMemoryReadiness(projectId, memoraxCodeHome, dependencies)
+        .then((value) => {
+        cacheReadiness(cacheKey, value);
+        return value;
+    })
+        .finally(() => {
+        if (readinessInFlight.get(cacheKey) === request)
+            readinessInFlight.delete(cacheKey);
+    });
+    readinessInFlight.set(cacheKey, request);
+    return request;
+}
+function readinessCacheKey(projectId, memoraxCodeHome, dependencies) {
+    if (dependencies === DEFAULT_READINESS_DEPENDENCIES) {
+        return `default\u0000${memoraxCodeHome}\u0000${projectId}`;
+    }
+    let scope = dependencyScopes.get(dependencies);
+    if (scope === undefined) {
+        scope = nextDependencyScope;
+        nextDependencyScope += 1;
+        dependencyScopes.set(dependencies, scope);
+    }
+    return `dependencies:${scope}\u0000${memoraxCodeHome}\u0000${projectId}`;
+}
+function readCachedReadiness(cacheKey) {
+    const cached = readinessCache.get(cacheKey);
+    if (!cached)
+        return undefined;
+    if (cached.expiresAt <= Date.now()) {
+        readinessCache.delete(cacheKey);
+        return undefined;
+    }
+    readinessCache.delete(cacheKey);
+    readinessCache.set(cacheKey, cached);
+    return cached.value;
+}
+function cacheReadiness(cacheKey, value) {
+    const now = Date.now();
+    for (const [key, cached] of readinessCache) {
+        if (cached.expiresAt <= now)
+            readinessCache.delete(key);
+    }
+    while (readinessCache.size >= READINESS_CACHE_CAPACITY) {
+        const oldest = readinessCache.keys().next().value;
+        if (typeof oldest !== "string")
+            break;
+        readinessCache.delete(oldest);
+    }
+    readinessCache.delete(cacheKey);
+    readinessCache.set(cacheKey, { expiresAt: now + readinessCacheTtl(value), value });
+}
+function readinessCacheTtl(value) {
+    if (value.status === "preparing")
+        return PREPARING_READINESS_CACHE_TTL_MS;
+    if (value.reason === "project_unresolved")
+        return UNRESOLVED_READINESS_CACHE_TTL_MS;
+    return STABLE_READINESS_CACHE_TTL_MS;
+}
+async function resolveRepoMemoryReadiness(projectId, memoraxCodeHome, dependencies) {
+    const repoRoot = (dependencies.resolveProjectRoot ?? memoryProjectRoot)(projectId);
+    if (!repoRoot)
+        return { status: "unknown", reason: "project_unresolved" };
+    try {
+        const active = await (dependencies.readActiveJob ?? readActiveRepoMemoryJob)({
+            memoraxCodeHome,
+            repoRealpath: repoRoot,
+        });
+        if (active.active)
+            return { status: "preparing", reason: "active_job" };
+    }
+    catch {
+        // Bundle validation remains useful when the optional job marker cannot be read.
+    }
+    const validateBundle = dependencies.validateBundle ?? validateRepoMemoryBundle;
+    const bundle = await withBundleValidationSlot(() => validateBundle(repoRoot));
+    if (bundle === "usable")
+        return { status: "ready", reason: "usable" };
+    if (bundle === "missing")
+        return { status: "not_ready", reason: "bundle_missing" };
+    if (bundle === "invalid")
+        return { status: "not_ready", reason: "bundle_invalid" };
+    return { status: "unknown", reason: "validator_unavailable" };
+}
+async function withBundleValidationSlot(task) {
+    await acquireBundleValidationSlot();
+    try {
+        return await task();
+    }
+    finally {
+        releaseBundleValidationSlot();
+    }
+}
+async function acquireBundleValidationSlot() {
+    if (activeBundleValidations < REPO_MEMORY_READINESS_MAX_CONCURRENT_VALIDATIONS) {
+        activeBundleValidations += 1;
+        return;
+    }
+    await new Promise((resolve) => validationWaiters.push(resolve));
+}
+function releaseBundleValidationSlot() {
+    const next = validationWaiters.shift();
+    if (next) {
+        // The released slot transfers directly to the oldest waiter.
+        next();
+        return;
+    }
+    activeBundleValidations -= 1;
+}
+async function readActiveRepoMemoryJob(input) {
+    const moduleUrl = new URL("../../memorax-code-adapter-common/src/repo-memory/repo-memory-job-marker.mjs", import.meta.url);
+    const markerModule = await import(moduleUrl.href);
+    if (typeof markerModule.readActiveRepoMemoryJobMarker !== "function") {
+        throw new Error("repo memory job marker reader is unavailable");
+    }
+    return markerModule.readActiveRepoMemoryJobMarker(input);
+}
+async function validateRepoMemoryBundle(repoRoot) {
+    const profileUrl = new URL(".repo_memory/PROFILE.md", pathToDirectoryUrl(repoRoot));
+    try {
+        await access(profileUrl, constants.R_OK);
+    }
+    catch {
+        return "missing";
+    }
+    const validatorUrl = new URL("../../memorax-code-codex-adapter/skills/memorax-code/scripts/validate_memory.py", import.meta.url);
+    try {
+        await access(validatorUrl, constants.R_OK);
+    }
+    catch {
+        return "unknown";
+    }
+    const python = process.env.MEMORAX_CODE_REPO_MEMORY_PYTHON_COMMAND || "python3";
+    try {
+        const { stdout } = await execFileAsync(python, [fileURLToPath(validatorUrl), repoRoot], {
+            encoding: "utf8",
+            timeout: 15_000,
+            maxBuffer: 1024 * 1024,
+        });
+        return readinessFromValidatorOutput(stdout);
+    }
+    catch (error) {
+        const stdout = typeof error?.stdout === "string"
+            ? error.stdout
+            : "";
+        const outcome = readinessFromValidatorOutput(stdout);
+        return outcome === "invalid" ? "invalid" : "unknown";
+    }
+}
+function readinessFromValidatorOutput(value) {
+    try {
+        const report = JSON.parse(value);
+        return report.ok === true ? "usable" : report.ok === false ? "invalid" : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function pathToDirectoryUrl(path) {
+    const normalized = path.endsWith("/") ? path : `${path}/`;
+    return pathToFileURL(normalized);
+}