opencode-graphiti 0.0.0-development

package/script/src/services/event-extractor.js

@@ -0,0 +1,669 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateEventSize = exports.extractStructuredEvents = exports.extractCompactionEvent = exports.extractSessionCreatedEvent = exports.extractAssistantMessageEvent = exports.extractUserMessageEvent = exports.createSessionEvent = void 0;
+const render_utils_js_1 = require("./render-utils.js");
+const MAX_SUMMARY = 200;
+const MAX_BODY = 4096;
+const priorityByCategory = {
+    decision: 0,
+    preference: 0,
+    "rule.load": 0,
+    "task.create": 0,
+    "task.update": 1,
+    "task.complete": 1,
+    "file.read": 1,
+    "file.write": 1,
+    "file.edit": 1,
+    "file.search": 2,
+    "cwd.change": 2,
+    "env.change": 2,
+    error: 2,
+    "git.activity": 3,
+    "subagent.start": 1,
+    "subagent.finish": 3,
+    "integration.call": 3,
+    intent: 0,
+    "data.import": 4,
+    discovery: 4,
+    message: 4,
+    "session.meta": 3,
+};
+const textEncoder = new TextEncoder();
+const eventRoles = new Set(["user", "assistant", "tool", "system"]);
+const normalizeWhitespace = (text) => text.replace(/\s+/g, " ").trim();
+const normalizeMemoryWhitespace = (text) => normalizeWhitespace((0, render_utils_js_1.sanitizeMemoryInput)(text));
+const summarize = (text) => normalizeWhitespace(text).slice(0, MAX_SUMMARY);
+const truncateBody = (text) => text.slice(0, MAX_BODY);
+const truncateDetail = (text) => text.slice(0, 600);
+const truncateContinuity = (text) => text.slice(0, 800);
+const USER_DECISION_PATTERN = /\b(?:must|should|keep|prefer|never|always|do not|don't|avoid|require|only)\b/i;
+const USER_TASK_PATTERN = /\b(?:implement|update|fix|continue|finish|complete|add|remove|refactor|investigate|revisit|clean(?:up)?|align|strip|prevent|enforce|make|keep)\b/i;
+const ASSISTANT_META_PATTERN = /\b(?:plan per target|i(?:'m| am| will| can| should| need to)|reading|checking|inspecting|updating|running|prepared|schedule(?:d)?|inject(?:ed|ion)|hot-tier|continuity)/i;
+const makeId = () => crypto.randomUUID?.() ??
+    `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+const asString = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
+const asEventRole = (value) => {
+    const role = asString(value);
+    return role && eventRoles.has(role)
+        ? role
+        : undefined;
+};
+const asNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+const toText = (value) => {
+    if (typeof value === "string") {
+        const normalized = normalizeWhitespace(value);
+        return normalized || undefined;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        const joined = value.map((item) => toText(item)).filter(Boolean).join(" ");
+        return joined || undefined;
+    }
+    const record = asRecord(value);
+    if (!record)
+        return undefined;
+    for (const key of [
+        "text",
+        "summary",
+        "message",
+        "content",
+        "body",
+        "description",
+        "prompt",
+        "query",
+        "title",
+        "name",
+        "value",
+        "reason",
+        "goal",
+        "status",
+        "intent",
+    ]) {
+        const result = toText(record[key]);
+        if (result)
+            return result;
+    }
+    return undefined;
+};
+const sanitizeExtractedText = (value) => value ? normalizeMemoryWhitespace(value) : "";
+const sanitizeRefs = (refs) => refs.map((ref) => (0, render_utils_js_1.sanitizeMemoryInput)(ref)).filter(Boolean);
+const shouldRejectUserText = (text) => !text || (0, render_utils_js_1.looksLikeToolTranscript)(text) || (0, render_utils_js_1.looksTranscriptHeavy)(text);
+const shouldPromoteUserDecision = (text) => USER_DECISION_PATTERN.test(text) && !(0, render_utils_js_1.looksLikeOperationalChatter)(text);
+const shouldPromoteUserTask = (text) => USER_TASK_PATTERN.test(text) && !(0, render_utils_js_1.looksLikeOperationalChatter)(text);
+const shouldPromoteAssistantSignal = (text) => !(0, render_utils_js_1.looksLikeOperationalChatter)(text) && !ASSISTANT_META_PATTERN.test(text) &&
+    !(0, render_utils_js_1.looksTranscriptHeavy)(text) && (0, render_utils_js_1.isHighValueMemoryText)(text);
+const shouldCaptureToolError = (tool, text) => {
+    const lowerTool = tool.toLowerCase();
+    const lowerText = text.toLowerCase();
+    return !hasLowerKeyword(lowerTool, "read", "open", "grep", "search", "glob") &&
+        hasLowerKeyword(lowerText, "error", "failed", "exception", "unable", "exit");
+};
+const sourceKindForRole = (role) => role === "assistant"
+    ? "assistant-response"
+    : role === "user"
+        ? "user-request"
+        : role === "tool"
+            ? "tool-activity"
+            : "system-state";
+const pickStrings = (values, limit = 8) => {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const text = toText(value);
+        if (!text || seen.has(text))
+            continue;
+        seen.add(text);
+        result.push(text);
+        if (result.length >= limit)
+            break;
+    }
+    return result;
+};
+const pickKeywords = (values, limit = 8) => pickStrings(values, limit).map((value) => summarize(value));
+const collectInlinePathRefs = (text) => {
+    const refs = new Set();
+    for (const match of text.matchAll(/(?:[A-Za-z0-9._-]+\/)+[A-Za-z0-9._-]+(?:\.[A-Za-z0-9]{1,8})?/g)) {
+        const value = match[0]?.trim();
+        if (value)
+            refs.add(value);
+    }
+    return [...refs];
+};
+const collectPathRefs = (value, refs = new Set()) => {
+    if (!value)
+        return [...refs];
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed &&
+            (trimmed.includes("/") || trimmed.includes("\\") ||
+                /\.[A-Za-z0-9]{1,8}$/.test(trimmed))) {
+            refs.add(trimmed);
+        }
+        return [...refs];
+    }
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectPathRefs(item, refs);
+        return [...refs];
+    }
+    const record = asRecord(value);
+    if (!record)
+        return [...refs];
+    const nestedCall = asRecord(record.call);
+    if (nestedCall?.tool !== undefined) {
+        collectPathRefs(nestedCall, refs);
+        collectPathRefs(nestedCall.tool, refs);
+    }
+    for (const [key, item] of Object.entries(record)) {
+        if (/(path|paths|file|files|ref|refs|cwd|directory)/i.test(key)) {
+            collectPathRefs(item, refs);
+        }
+    }
+    return [...refs];
+};
+const hasLowerKeyword = (haystack, ...needles) => {
+    if (!haystack)
+        return false;
+    return needles.some((needle) => haystack.includes(needle));
+};
+const hasKeyword = (haystack, ...needles) => hasLowerKeyword(haystack?.toLowerCase(), ...needles);
+const compactParts = (...parts) => {
+    const fragments = [];
+    for (const part of parts) {
+        const value = part ? normalizeWhitespace(part) : "";
+        if (!value)
+            continue;
+        const normalized = value.toLowerCase();
+        if (fragments.some((fragment) => fragment.toLowerCase() === normalized)) {
+            continue;
+        }
+        fragments.push(value);
+    }
+    const compact = fragments.join(" — ");
+    return compact || undefined;
+};
+const collectMetadataKeywords = (props) => pickKeywords([
+    props.tool,
+    props.name,
+    props.integration,
+    props.status,
+    props.result,
+    props.reason,
+    props.cwd,
+]);
+const compactToolMetadata = (props, extra = {}) => {
+    const metadata = {};
+    for (const [key, value] of Object.entries({
+        tool: props.tool,
+        name: props.name,
+        integration: props.integration,
+        status: props.status,
+        result: props.result,
+        exitCode: props.exitCode,
+        cwd: props.cwd,
+        blocking: props.blocking,
+        resolved: props.resolved,
+        ...extra,
+    })) {
+        if (typeof value === "string" || typeof value === "number" ||
+            typeof value === "boolean") {
+            metadata[key] = value;
+        }
+    }
+    return metadata;
+};
+const buildContinuityText = (summary, detail, refs, keywords) => {
+    const fragments = [];
+    for (const candidate of [summary, detail, refs?.join(" "), keywords?.join(" ")]) {
+        const value = candidate ? normalizeWhitespace(candidate) : "";
+        if (!value)
+            continue;
+        const normalized = value.toLowerCase();
+        let replaced = false;
+        for (let index = fragments.length - 1; index >= 0; index -= 1) {
+            const existing = fragments[index];
+            const existingNormalized = existing.toLowerCase();
+            if (existingNormalized === normalized ||
+                existingNormalized.includes(normalized)) {
+                replaced = true;
+                break;
+            }
+            if (normalized.includes(existingNormalized)) {
+                fragments.splice(index, 1);
+            }
+        }
+        if (!replaced)
+            fragments.push(value);
+    }
+    const continuity = fragments.join(" ");
+    return continuity ? truncateContinuity(continuity) : undefined;
+};
+const compactMessageBody = (text) => {
+    const normalized = normalizeWhitespace(text);
+    if (!normalized)
+        return undefined;
+    if ((0, render_utils_js_1.looksTranscriptHeavy)(normalized) || (0, render_utils_js_1.looksLikeToolTranscript)(normalized)) {
+        return undefined;
+    }
+    return truncateBody(normalized.slice(0, 480));
+};
+const buildToolActivityContext = (tool, text, refs, props, options = {}) => {
+    const normalizedText = (0, render_utils_js_1.looksTranscriptHeavy)(text) || (0, render_utils_js_1.looksLikeToolTranscript)(text)
+        ? ""
+        : sanitizeExtractedText(text);
+    const cleanRefs = sanitizeRefs(refs);
+    const refSummary = cleanRefs.slice(0, 3).join(", ");
+    const statusSummary = compactParts(asString(props.status), asString(props.result), typeof props.exitCode === "number" ? `exit ${props.exitCode}` : undefined);
+    const summary = compactParts(options.summaryPrefix ?? tool, refSummary, statusSummary) ?? `${tool} activity`;
+    const detail = compactParts(summarize(normalizedText), statusSummary, cleanRefs.length > 0
+        ? `refs ${cleanRefs.slice(0, 4).join(", ")}`
+        : undefined);
+    const keywords = pickKeywords([
+        tool,
+        ...cleanRefs,
+        ...collectMetadataKeywords(props),
+        ...(options.extraKeywords ?? []),
+    ]);
+    return {
+        summary,
+        body: options.preserveBody ? compactMessageBody(normalizedText) : undefined,
+        detail,
+        continuityText: buildContinuityText(summary, detail, cleanRefs, keywords),
+        keywords,
+        sourceKind: options.sourceKind ?? "tool-activity",
+        refs: cleanRefs,
+        metadata: compactToolMetadata(props, options.extraMetadata),
+    };
+};
+const normalizeInput = (input) => {
+    const props = input.properties ?? {};
+    const text = sanitizeExtractedText(input.messageText ?? toText(props) ?? "");
+    const refs = [
+        ...new Set([...collectPathRefs(props), ...collectInlinePathRefs(text)]),
+    ];
+    return {
+        eventType: input.eventType,
+        props,
+        sessionId: input.sessionId,
+        text,
+        refs,
+        role: input.role ?? "system",
+        messageCount: asNumber(input.messageCount) ?? 1,
+    };
+};
+const createEvent = (category, role, context) => ({
+    id: makeId(),
+    ts: Date.now(),
+    category,
+    priority: priorityByCategory[category],
+    role,
+    summary: summarize(context.summary),
+    body: context.body ? truncateBody(context.body) : undefined,
+    detail: context.detail ? truncateDetail(context.detail) : undefined,
+    continuityText: context.continuityText
+        ? truncateContinuity(context.continuityText)
+        : undefined,
+    keywords: context.keywords?.filter(Boolean).slice(0, 8),
+    sourceKind: context.sourceKind,
+    refs: context.refs?.filter(Boolean),
+    metadata: context.metadata,
+});
+const createSessionEvent = (category, role, context) => createEvent(category, role, context);
+exports.createSessionEvent = createSessionEvent;
+const extractUserMessageEvent = (text, messageCount) => createEvent(messageCount <= 1 ? "intent" : "message", "user", {
+    summary: text,
+    body: compactMessageBody(text),
+    detail: summarize(text),
+    continuityText: buildContinuityText(text, summarize(text)),
+    keywords: pickKeywords([text]),
+    sourceKind: "user-request",
+});
+exports.extractUserMessageEvent = extractUserMessageEvent;
+const extractAssistantMessageEvent = (text) => createEvent("message", "assistant", {
+    summary: summarize(text),
+    detail: compactParts("Assistant response", summarize(text)),
+    continuityText: buildContinuityText(summarize(text), summarize(text)),
+    keywords: pickKeywords([text]),
+    sourceKind: "assistant-response",
+});
+exports.extractAssistantMessageEvent = extractAssistantMessageEvent;
+const extractSessionCreatedEvent = (sessionId) => createEvent("session.meta", "system", {
+    summary: `Session created${sessionId ? `: ${sessionId}` : ""}`,
+    detail: sessionId
+        ? `Session ${sessionId} initialized`
+        : "Session initialized",
+    continuityText: sessionId
+        ? `session created ${sessionId}`
+        : "session created",
+    keywords: pickKeywords([sessionId, "session", "created"]),
+    sourceKind: "system-state",
+    refs: sessionId ? [sessionId] : undefined,
+    metadata: sessionId ? { sessionId } : undefined,
+});
+exports.extractSessionCreatedEvent = extractSessionCreatedEvent;
+const extractCompactionEvent = (summary) => createEvent("task.update", "system", {
+    summary: `Session compacted: ${summary}`,
+    detail: summarize(summary),
+    continuityText: buildContinuityText(`Session compacted: ${summary}`, summary),
+    keywords: pickKeywords([summary, "compacted"]),
+    sourceKind: "system-state",
+    metadata: { compacted: true },
+});
+exports.extractCompactionEvent = extractCompactionEvent;
+const inferTaskCategory = (text) => {
+    if (hasKeyword(text, "complete", "completed", "done", "finished", "resolved", "fixed")) {
+        return "task.complete";
+    }
+    if (hasKeyword(text, "start", "create", "begin", "plan", "goal", "implement")) {
+        return "task.create";
+    }
+    return "task.update";
+};
+const extractFromHookPayload = (input) => {
+    const normalized = normalizeInput(input);
+    const { eventType, props, sessionId, text, refs, role, messageCount } = normalized;
+    if (eventType === "session.created") {
+        return [
+            (0, exports.extractSessionCreatedEvent)(sessionId ?? asString(asRecord(props.info)?.id)),
+        ];
+    }
+    if (eventType === "session.compacted" && text) {
+        return [(0, exports.extractCompactionEvent)(text)];
+    }
+    if (eventType === "message.updated" && role === "assistant" && text) {
+        return [(0, exports.extractAssistantMessageEvent)(text)];
+    }
+    if (eventType === "chat.message" && text) {
+        return [(0, exports.extractUserMessageEvent)(text, messageCount)];
+    }
+    const genericSummary = text || eventType;
+    return [createEvent("session.meta", role, {
+            summary: genericSummary,
+            detail: summarize(text),
+            continuityText: buildContinuityText(genericSummary, summarize(text), refs),
+            keywords: pickKeywords([eventType, text, ...refs]),
+            sourceKind: role === "tool"
+                ? "tool-activity"
+                : role === "assistant"
+                    ? "assistant-response"
+                    : role === "user"
+                        ? "user-request"
+                        : "system-state",
+            refs,
+            metadata: { eventType },
+        })];
+};
+const extractStructuredEvents = (input) => {
+    const normalized = normalizeInput(input);
+    const { eventType, props, text, refs, role, messageCount } = normalized;
+    if (eventType === "chat.message") {
+        if (shouldRejectUserText(text))
+            return [];
+        const events = [(0, exports.extractUserMessageEvent)(text, messageCount)];
+        const lower = text.toLowerCase();
+        if (shouldPromoteUserDecision(text) &&
+            hasLowerKeyword(lower, "prefer", "please", "always", "never")) {
+            events.push(createEvent("preference", "user", {
+                summary: text,
+                detail: summarize(text),
+                continuityText: buildContinuityText(text, summarize(text)),
+                keywords: pickKeywords([text, "preference"]),
+                sourceKind: "user-request",
+            }));
+        }
+        if (shouldPromoteUserDecision(text) &&
+            hasLowerKeyword(lower, "decide", "decision", "must", "should", "keep ")) {
+            events.push(createEvent("decision", "user", {
+                summary: text,
+                detail: summarize(text),
+                continuityText: buildContinuityText(text, summarize(text)),
+                keywords: pickKeywords([text, "decision"]),
+                sourceKind: "user-request",
+            }));
+        }
+        if (hasLowerKeyword(lower, "import", "paste", "uploaded", "dataset", "csv", "json")) {
+            events.push(createEvent("data.import", "user", {
+                summary: text,
+                detail: compactParts("Imported or referenced data", summarize(text)),
+                continuityText: buildContinuityText(text, summarize(text), refs),
+                keywords: pickKeywords([text, ...refs, "data"]),
+                sourceKind: "user-request",
+                refs,
+            }));
+        }
+        if (shouldPromoteUserTask(text) && messageCount > 1) {
+            events.push(createEvent(inferTaskCategory(text), "user", {
+                summary: text,
+                detail: compactParts("User task", summarize(text)),
+                continuityText: buildContinuityText(text, summarize(text), refs),
+                keywords: pickKeywords([text, ...refs, "task"]),
+                sourceKind: "user-request",
+                refs,
+            }));
+        }
+        return events;
+    }
+    if (eventType === "message.updated") {
+        const resolvedRole = input.role ?? asEventRole(asRecord(props.info)?.role);
+        if (resolvedRole === "assistant" && text) {
+            if (!shouldPromoteAssistantSignal(text)) {
+                return [];
+            }
+            const events = [(0, exports.extractAssistantMessageEvent)(text)];
+            if (hasKeyword(text, "discovered", "found", "identified", "confirmed")) {
+                events.push(createEvent("discovery", "assistant", {
+                    summary: text,
+                    detail: summarize(text),
+                    continuityText: buildContinuityText(text, summarize(text), refs),
+                    keywords: pickKeywords([text, ...refs, "discovery"]),
+                    sourceKind: "assistant-response",
+                    refs,
+                }));
+            }
+            return events;
+        }
+    }
+    if (eventType === "task.updated") {
+        const task = asRecord(props.task) ?? props;
+        const summary = toText(task) ?? "Task updated";
+        return [createEvent(inferTaskCategory(summary), "system", {
+                summary,
+                detail: compactParts("Task update", summarize(summary)),
+                continuityText: buildContinuityText(summary, summarize(summary), refs),
+                keywords: pickKeywords([summary, task.id, task.path, ...refs]),
+                sourceKind: "system-state",
+                refs: pickStrings([task.id, task.path, ...refs]),
+                metadata: compactToolMetadata(task),
+            })];
+    }
+    if (eventType === "rules.loaded") {
+        const summary = pickStrings([props.name, props.path, props.source, text]).join(" — ") ||
+            "Rules loaded";
+        return [createEvent("rule.load", "system", {
+                summary,
+                detail: compactParts("Rules loaded", text || summary),
+                continuityText: buildContinuityText(summary, text || summary, refs),
+                keywords: pickKeywords([summary, ...refs, "rules"]),
+                sourceKind: "system-state",
+                refs,
+                metadata: compactToolMetadata(props),
+            })];
+    }
+    if (eventType === "tool.called" || eventType === "tool.completed") {
+        const tool = asString(props.tool) ?? asString(props.name) ??
+            toText(asRecord(props.call)?.tool) ?? "tool";
+        const summaryText = text || `${tool} activity`;
+        const lowerTool = tool.toLowerCase();
+        const lowerText = summaryText.toLowerCase();
+        if (hasLowerKeyword(lowerTool, "read", "open") ||
+            hasLowerKeyword(lowerText, "read file", "opened")) {
+            return [
+                createEvent("file.read", "tool", buildToolActivityContext(tool, summaryText, refs, props, {
+                    summaryPrefix: "Read",
+                    extraKeywords: ["file", "read"],
+                })),
+            ];
+        }
+        if (hasLowerKeyword(lowerTool, "write", "create") ||
+            hasLowerKeyword(lowerText, "wrote", "created file")) {
+            return [
+                createEvent("file.write", "tool", buildToolActivityContext(tool, summaryText, refs, props, {
+                    summaryPrefix: "Wrote",
+                    extraKeywords: ["file", "write"],
+                })),
+            ];
+        }
+        if (hasLowerKeyword(lowerTool, "edit", "patch", "replace") ||
+            hasLowerKeyword(lowerText, "updated file", "edited")) {
+            return [
+                createEvent("file.edit", "tool", buildToolActivityContext(tool, summaryText, refs, props, {
+                    summaryPrefix: "Edited",
+                    extraKeywords: ["file", "edit"],
+                })),
+            ];
+        }
+        if (hasLowerKeyword(lowerTool, "grep", "search", "glob") ||
+            hasLowerKeyword(lowerText, "searched", "query")) {
+            return [
+                createEvent("file.search", "tool", buildToolActivityContext(tool, summaryText, refs, props, {
+                    summaryPrefix: "Searched",
+                    extraKeywords: ["search"],
+                })),
+            ];
+        }
+        if (hasLowerKeyword(lowerTool, "git") ||
+            hasLowerKeyword(lowerText, "branch", "commit", "merge", "rebase", "push", "stash")) {
+            return [
+                createEvent("git.activity", "tool", buildToolActivityContext(tool, summaryText, refs, props, {
+                    summaryPrefix: "Git",
+                    extraKeywords: ["git"],
+                    preserveBody: true,
+                })),
+            ];
+        }
+        const isIntegrationActivity = hasLowerKeyword(lowerTool, "graphiti", "mcp", "redis", "http") ||
+            asString(props.integration);
+        const isUnresolvedToolFailure = props.resolved === false;
+        if (shouldCaptureToolError(tool, summaryText) &&
+            (!isIntegrationActivity || isUnresolvedToolFailure)) {
+            return [createEvent("error", "tool", {
+                    ...buildToolActivityContext(tool, summaryText, refs, props, {
+                        summaryPrefix: "Tool error",
+                        preserveBody: true,
+                        extraKeywords: ["error", "failed"],
+                        extraMetadata: isUnresolvedToolFailure ? { resolved: false } : {},
+                    }),
+                })];
+        }
+        if (isIntegrationActivity) {
+            return [
+                createEvent("integration.call", "tool", buildToolActivityContext(tool, summaryText, refs, props, {
+                    summaryPrefix: "Integration",
+                    extraKeywords: ["integration"],
+                })),
+            ];
+        }
+    }
+    if (eventType === "environment.updated") {
+        const summary = text || "Environment updated";
+        const entries = [];
+        if (hasKeyword(summary, "cwd", "directory", "working directory")) {
+            entries.push(createEvent("cwd.change", "system", {
+                summary,
+                detail: compactParts("Working directory updated", text),
+                continuityText: buildContinuityText(summary, text, refs),
+                keywords: pickKeywords([summary, ...refs, "cwd"]),
+                sourceKind: "system-state",
+                refs,
+                metadata: compactToolMetadata(props),
+            }));
+        }
+        entries.push(createEvent("env.change", "system", {
+            summary,
+            detail: compactParts("Environment updated", text),
+            continuityText: buildContinuityText(summary, text, refs),
+            keywords: pickKeywords([summary, ...refs, "environment"]),
+            sourceKind: "system-state",
+            refs,
+            metadata: compactToolMetadata(props),
+        }));
+        return entries;
+    }
+    if (eventType === "subagent.started" || eventType === "subagent.finished") {
+        return [
+            createEvent(eventType === "subagent.started" ? "subagent.start" : "subagent.finish", "system", {
+                summary: text || eventType,
+                detail: compactParts(eventType === "subagent.started"
+                    ? "Subagent started"
+                    : "Subagent finished", text),
+                continuityText: buildContinuityText(text || eventType, text, refs),
+                keywords: pickKeywords([
+                    text,
+                    props.agentId,
+                    props.sessionId,
+                    ...refs,
+                ]),
+                sourceKind: "system-state",
+                refs: pickStrings([props.agentId, props.sessionId, ...refs]),
+                metadata: compactToolMetadata(props),
+            }),
+        ];
+    }
+    if (eventType === "session.idle") {
+        return [createEvent("session.meta", "system", {
+                summary: text || "Session idle",
+                detail: compactParts("Session idle", text),
+                continuityText: buildContinuityText(text || "Session idle", text, refs),
+                keywords: pickKeywords([text, eventType, ...refs]),
+                sourceKind: "system-state",
+                refs,
+                metadata: { ...props, eventType },
+            })];
+    }
+    if (text) {
+        const lower = text.toLowerCase();
+        if (role !== "assistant" &&
+            hasLowerKeyword(lower, "error", "failed", "exception", "blocker")) {
+            return [createEvent("error", role, {
+                    summary: text,
+                    detail: summarize(text),
+                    continuityText: buildContinuityText(text, summarize(text), refs),
+                    keywords: pickKeywords([text, ...refs, "error"]),
+                    sourceKind: sourceKindForRole(role),
+                    refs,
+                    metadata: { ...props, resolved: false, eventType },
+                })];
+        }
+        if (role !== "assistant" &&
+            hasLowerKeyword(lower, "discover", "found", "inspect", "observed")) {
+            return [createEvent("discovery", role, {
+                    summary: text,
+                    detail: summarize(text),
+                    continuityText: buildContinuityText(text, summarize(text), refs),
+                    keywords: pickKeywords([text, ...refs, "discovery"]),
+                    sourceKind: sourceKindForRole(role),
+                    refs,
+                    metadata: { ...props, eventType },
+                })];
+        }
+        return [createEvent("message", role, {
+                summary: text,
+                body: role === "user" ? compactMessageBody(text) : undefined,
+                detail: summarize(text),
+                continuityText: buildContinuityText(text, summarize(text), refs),
+                keywords: pickKeywords([text, ...refs]),
+                sourceKind: sourceKindForRole(role),
+                refs,
+                metadata: { ...props, eventType },
+            })];
+    }
+    return extractFromHookPayload(input);
+};
+exports.extractStructuredEvents = extractStructuredEvents;
+const estimateEventSize = (event) => textEncoder.encode(JSON.stringify(event)).length;
+exports.estimateEventSize = estimateEventSize;

package/script/src/services/graphiti-async.d.ts

@@ -0,0 +1,22 @@
+import type { BatchDrainService } from "./batch-drain.js";
+import type { GraphitiMcpClient } from "./graphiti-mcp.js";
+import type { RedisCacheService } from "./redis-cache.js";
+export declare class GraphitiAsyncService {
+    private readonly graphiti;
+    private readonly cache;
+    private readonly drain;
+    private readonly drainRetryDelayMs;
+    private readonly drainInFlight;
+    private readonly drainRetryTimers;
+    private readonly drainRecoveryTimers;
+    private readonly refreshInFlight;
+    private readonly primerInFlight;
+    constructor(graphiti: GraphitiMcpClient, cache: RedisCacheService, drain: BatchDrainService, drainRetryDelayMs?: number);
+    private armDrainRetry;
+    private armDrainRecovery;
+    private clearDrainRecovery;
+    schedulePrimer(groupId: string): void;
+    scheduleCacheRefresh(groupId: string, query: string): void;
+    scheduleDrain(groupId: string): void;
+}
+//# sourceMappingURL=graphiti-async.d.ts.map