@memorax/memorax-code 0.1.7 → 0.1.9

package/lib/memorax-code-backend/dist/viewer/projection/user.js

@@ -1,168 +0,0 @@
-import { isTraceClient } from "../../trace/context.js";
-/**
- * Projects raw Viewer events into the deliberately small user-facing summary contract.
- * Conversation, memory, session, turn, and diagnostic fields never cross this boundary.
- */
-export function projectMemoryViewerUserData(events) {
-    const turnActivities = projectTurnActivities(events);
-    const activities = [
-        ...turnActivities,
-        ...events.flatMap((event) => {
-            if (event.type === "memory_retrieve" || event.type === "memory_cli_search") {
-                const occurredAt = canonicalUserActivityTimestamp(event.timestamp);
-                if (!occurredAt)
-                    return [];
-                const nativeTranscriptActivity = isClaudeNativeTranscriptMemoryActivity(event);
-                return [{
-                        kind: "search",
-                        occurredAt,
-                        source: event.type === "memory_cli_search" ? "assistant" : "automatic",
-                        status: event.ok ? "completed" : "failed",
-                        count: event.ok
-                            ? nativeTranscriptActivity
-                                ? safeNativeTranscriptSearchItemCount(event)
-                                : event.itemCount ?? event.results?.length ?? 0
-                            : 0,
-                        ...safeProjectFields(event),
-                    }];
-            }
-            if (event.type !== "memory_cli_add" && event.type !== "memory_writeback")
-                return [];
-            const occurredAt = canonicalUserActivityTimestamp(event.timestamp);
-            if (!occurredAt)
-                return [];
-            const nativeTranscriptActivity = isClaudeNativeTranscriptMemoryActivity(event);
-            return [{
-                    kind: "add",
-                    occurredAt,
-                    source: event.type === "memory_cli_add" ? "assistant" : "automatic",
-                    status: nativeTranscriptActivity && event.ok ? "unknown" : addStatus(event),
-                    count: nativeTranscriptActivity && event.ok ? null : addCount(event),
-                    ...safeProjectFields(event),
-                }];
-        }),
-    ].sort(compareUserActivitiesNewestFirst);
-    return {
-        activities,
-        summary: {
-            turnCount: turnActivities.length,
-            searchOperationCount: countActivities(activities, "search"),
-            searchedMemoryCount: sumActivityCounts(activities, "search"),
-            addOperationCount: countActivities(activities, "add"),
-            addedMemoryCount: activities
-                .filter((activity) => activity.kind === "add" && activity.status === "saved")
-                .reduce((total, activity) => total + (activity.count ?? 0), 0),
-            processingCount: activities.filter((activity) => activity.status === "processing").length,
-            unknownCount: activities.filter((activity) => (activity.kind !== "turn"
-                && activity.count === null
-                && activity.status !== "processing"
-                && activity.status !== "failed")).length,
-            failedCount: activities.filter((activity) => activity.status === "failed").length,
-        },
-    };
-}
-function isClaudeNativeTranscriptMemoryActivity(event) {
-    return event.client === "claude"
-        && event.id.startsWith("claude-local:")
-        && (event.type === "memory_cli_search" || event.type === "memory_cli_add");
-}
-function safeNativeTranscriptSearchItemCount(event) {
-    return Number.isSafeInteger(event.itemCount)
-        && (event.itemCount ?? -1) >= 0
-        && (event.itemCount ?? 101) <= 100
-        ? event.itemCount
-        : null;
-}
-function projectTurnActivities(events) {
-    const turns = new Map();
-    for (const event of events) {
-        if (!event.sessionId || !event.turnId || (event.type !== "turn_start" && event.type !== "turn_end"))
-            continue;
-        const key = `${traceClient(event)}\u0000${event.sessionId}\u0000${event.turnId}`;
-        const turn = turns.get(key) ?? {};
-        if (event.type === "turn_start")
-            turn.start = event;
-        else
-            turn.end = event;
-        turns.set(key, turn);
-    }
-    return [...turns.values()].flatMap((turn) => {
-        const anchor = turn.start ?? turn.end;
-        if (!anchor)
-            return [];
-        const occurredAt = canonicalUserActivityTimestamp(turn.start?.timestamp)
-            ?? canonicalUserActivityTimestamp(turn.end?.timestamp)
-            ?? canonicalUserActivityTimestamp(anchor.timestamp);
-        if (!occurredAt)
-            return [];
-        return [{
-                kind: "turn",
-                occurredAt,
-                source: "client",
-                status: turn.end?.turnOutcome === "interrupted"
-                    || (!turn.end && turn.start?.turnOutcome === "interrupted")
-                    ? "interrupted"
-                    : turn.end
-                        ? "completed"
-                        : "processing",
-                count: null,
-                ...safeProjectFields(anchor),
-            }];
-    });
-}
-function canonicalUserActivityTimestamp(value) {
-    if (typeof value !== "string" || value.length > 512)
-        return undefined;
-    const parsed = Date.parse(value.trim());
-    if (!Number.isFinite(parsed))
-        return undefined;
-    return new Date(parsed).toISOString();
-}
-function traceClient(event) {
-    return isTraceClient(event.client) ? event.client : "codex";
-}
-function safeProjectFields(event) {
-    return {
-        ...(event.projectId ? { projectId: event.projectId } : {}),
-        ...(event.projectLabel ? { projectLabel: event.projectLabel } : {}),
-    };
-}
-function addStatus(event) {
-    if (!event.ok || event.writebackOutcome === "failed")
-        return "failed";
-    if (event.writebackOutcome === "pending")
-        return "processing";
-    if (event.writebackOutcome === "saved")
-        return "saved";
-    if (event.writebackOutcome === "skipped")
-        return "skipped";
-    if (event.writebackOutcome === "completed")
-        return "completed";
-    if (event.savedMemoryCount !== undefined)
-        return event.savedMemoryCount > 0 ? "saved" : "skipped";
-    return "unknown";
-}
-function addCount(event) {
-    if (!event.ok || event.writebackOutcome === "failed")
-        return 0;
-    if (event.savedMemoryCount !== undefined)
-        return event.savedMemoryCount;
-    if (event.writebackOutcome === "skipped")
-        return 0;
-    return null;
-}
-function compareUserActivitiesNewestFirst(left, right) {
-    return timestampOrder(right.occurredAt) - timestampOrder(left.occurredAt);
-}
-function timestampOrder(value) {
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : 0;
-}
-function countActivities(activities, kind) {
-    return activities.filter((activity) => activity.kind === kind).length;
-}
-function sumActivityCounts(activities, kind) {
-    return activities
-        .filter((activity) => activity.kind === kind)
-        .reduce((total, activity) => total + (activity.count ?? 0), 0);
-}

package/lib/memorax-code-backend/dist/viewer/projection/writeback-status.js

@@ -1,97 +0,0 @@
-import { completeMemoryWritebackTask, memoryText, memoryWritebackTaskEventKey, memoryWritebackTaskOutcome, memoryWritebackTaskOutcomeForStatus, nonNegativeInteger, projectMemoryWritebackTasks, stringArray, } from "../../memory/writeback-task-projection.js";
-export { memoryText, nonNegativeInteger, stringArray, };
-export function pendingMemoryViewerWritebacks(eventsToCheck) {
-    const tasks = new Map(projectMemoryWritebackTasks(eventsToCheck.flatMap(memoryViewerWritebackProjectionRecord)).map((task) => [memoryWritebackTaskEventKey(task), task]));
-    return eventsToCheck.filter((event) => {
-        const task = tasks.get(memoryViewerWritebackEventKey(event));
-        return task?.accepted === true && task.completion.outcome === "pending";
-    });
-}
-export function completeMemoryViewerWriteback(event, status) {
-    return applyMemoryWritebackTaskCompletion(event, completeMemoryWritebackTask(status), false);
-}
-export function foldMemoryViewerWritebackStatuses(allEvents) {
-    const tasks = new Map(projectMemoryWritebackTasks(allEvents.flatMap(memoryViewerWritebackProjectionRecord)).map((task) => [memoryWritebackTaskEventKey(task), task]));
-    return allEvents
-        .filter((event) => event.type !== "memory_writeback_status")
-        .map((event) => {
-        const task = tasks.get(memoryViewerWritebackEventKey(event));
-        return task?.statusEventId
-            ? applyMemoryWritebackTaskCompletion(event, task.completion, true)
-            : event;
-    });
-}
-export function memoryViewerWritebackOutcome(value) {
-    return memoryWritebackTaskOutcome(value);
-}
-export function writebackOutcomeForStatus(status, result = {}) {
-    return memoryWritebackTaskOutcomeForStatus(status, result);
-}
-function memoryViewerWritebackProjectionRecord(event) {
-    if ((event.type === "memory_writeback" || event.type === "memory_cli_add")
-        && event.taskId
-        && event.writebackStatus) {
-        return [{
-                kind: "task",
-                eventId: event.id,
-                timestamp: event.timestamp,
-                client: event.client,
-                ...(event.sessionId ? { sessionId: event.sessionId } : {}),
-                ...(event.turnId ? { turnId: event.turnId } : {}),
-                ok: event.ok,
-                taskId: event.taskId,
-                status: event.writebackStatus,
-            }];
-    }
-    if (event.type !== "memory_writeback_status" || !event.writebackStatus)
-        return [];
-    if (!event.originalEventId && (!event.sessionId || !event.taskId))
-        return [];
-    return [{
-            kind: "status",
-            eventId: event.id,
-            timestamp: event.timestamp,
-            client: event.client,
-            ...(event.sessionId ? { sessionId: event.sessionId } : {}),
-            ...(event.turnId ? { turnId: event.turnId } : {}),
-            ...(event.taskId ? { taskId: event.taskId } : {}),
-            ...(event.originalEventId ? { originalEventId: event.originalEventId } : {}),
-            completion: completeMemoryWritebackTask({
-                status: event.writebackStatus,
-                outcome: event.writebackOutcome,
-                savedMemoryCount: event.savedMemoryCount,
-                savedMemoryIds: event.savedMemoryIds,
-                savedMemories: event.savedMemories,
-                error: event.error,
-            }),
-        }];
-}
-function memoryViewerWritebackEventKey(event) {
-    return memoryWritebackTaskEventKey({
-        eventId: event.id,
-        client: event.client,
-        ...(event.sessionId ? { sessionId: event.sessionId } : {}),
-    });
-}
-function applyMemoryWritebackTaskCompletion(event, completion, replaceError) {
-    const base = replaceError
-        ? (({ error: _previousError, ...remaining }) => remaining)(event)
-        : event;
-    return {
-        ...base,
-        ok: completion.ok,
-        writebackStatus: completion.status,
-        writebackOutcome: completion.outcome,
-        ...(completion.savedMemories?.length ? {
-            content: completion.savedMemories.join("\n\n"),
-            savedMemories: completion.savedMemories,
-        } : {}),
-        ...(completion.savedMemoryIds?.length ? {
-            savedMemoryIds: completion.savedMemoryIds,
-        } : {}),
-        ...(completion.savedMemoryCount === undefined ? {} : {
-            savedMemoryCount: completion.savedMemoryCount,
-        }),
-        ...(completion.error ? { error: completion.error } : {}),
-    };
-}