@memorax/memorax-code 0.1.7 → 0.1.9

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

@@ -1,377 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { readIncrementalJsonlProjection, } from "../shared/incremental-jsonl-projection.js";
-import { memoryProjectFromUnknown, resolveMemoryProject, } from "./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/repository/readiness.js

@@ -1,188 +0,0 @@
-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);
-}