opencode-graphiti 0.1.0 → 0.1.2

package/script/src/handlers/chat.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChatHandler = createChatHandler;
+const context_js_1 = require("../services/context.js");
+const context_limit_js_1 = require("../services/context-limit.js");
+const logger_js_1 = require("../services/logger.js");
+const utils_js_1 = require("../utils.js");
+/** Creates the `chat.message` hook handler. */
+function createChatHandler(deps) {
+    const { sessionManager, injectionInterval, client } = deps;
+    const removeSyntheticMemoryParts = (parts) => parts.filter((part) => {
+        const synthetic = part.synthetic;
+        const id = typeof part.id === "string"
+            ? String(part.id)
+            : "";
+        if (!synthetic)
+            return true;
+        if (id.startsWith("graphiti-memory-"))
+            return false;
+        if (id.startsWith("graphiti-refresh-"))
+            return false;
+        return true;
+    });
+    const injectMemoryContext = async (state, messageText, output, prefix, useUserScope, characterBudget) => {
+        const userGroupId = state.userGroupId;
+        const projectFactsPromise = client.searchFacts({
+            query: messageText,
+            groupIds: [state.groupId],
+            maxFacts: 50,
+        });
+        const projectNodesPromise = client.searchNodes({
+            query: messageText,
+            groupIds: [state.groupId],
+            maxNodes: 30,
+        });
+        const userFactsPromise = useUserScope && userGroupId
+            ? client.searchFacts({
+                query: messageText,
+                groupIds: [userGroupId],
+                maxFacts: 20,
+            })
+            : Promise.resolve([]);
+        const userNodesPromise = useUserScope && userGroupId
+            ? client.searchNodes({
+                query: messageText,
+                groupIds: [userGroupId],
+                maxNodes: 10,
+            })
+            : Promise.resolve([]);
+        const [projectFacts, projectNodes, userFacts, userNodes] = await Promise
+            .all([
+            projectFactsPromise,
+            projectNodesPromise,
+            userFactsPromise,
+            userNodesPromise,
+        ]);
+        const projectContext = (0, context_js_1.formatMemoryContext)(projectFacts, projectNodes);
+        const userContext = (0, context_js_1.formatMemoryContext)(userFacts, userNodes);
+        if (!projectContext && !userContext)
+            return;
+        const projectBudget = useUserScope
+            ? Math.floor(characterBudget * 0.7)
+            : characterBudget;
+        const userBudget = characterBudget - projectBudget;
+        const truncatedProject = projectContext.slice(0, projectBudget);
+        const truncatedUser = useUserScope ? userContext.slice(0, userBudget) : "";
+        const memoryContext = [truncatedProject, truncatedUser]
+            .filter((section) => section.trim().length > 0)
+            .join("\n\n")
+            .slice(0, characterBudget);
+        if (!memoryContext)
+            return;
+        output.parts.unshift({
+            type: "text",
+            text: memoryContext,
+            id: `${prefix}${Date.now()}`,
+            sessionID: output.message.sessionID,
+            messageID: output.message.id,
+            synthetic: true,
+        });
+        logger_js_1.logger.info(`Injected ${projectFacts.length + userFacts.length} facts and ${projectNodes.length + userNodes.length} nodes`);
+    };
+    return async ({ sessionID }, output) => {
+        if (await sessionManager.isSubagentSession(sessionID)) {
+            logger_js_1.logger.debug("Ignoring subagent chat message:", sessionID);
+            return;
+        }
+        const { state, resolved } = await sessionManager.resolveSessionState(sessionID);
+        if (!resolved) {
+            output.allow_buffering = true;
+            logger_js_1.logger.debug("Unable to resolve session for message:", { sessionID });
+            return;
+        }
+        if (!state?.isMain) {
+            logger_js_1.logger.debug("Ignoring subagent chat message:", sessionID);
+            return;
+        }
+        state.messageCount++;
+        const messageText = (0, utils_js_1.extractTextFromParts)(output.parts);
+        if (!messageText)
+            return;
+        state.pendingMessages.push(`User: ${messageText}`);
+        logger_js_1.logger.info("Buffered user message", {
+            hook: "chat.message",
+            sessionID,
+            messageLength: messageText.length,
+        });
+        const shouldInjectOnFirst = !state.injectedMemories;
+        const shouldReinject = !shouldInjectOnFirst &&
+            injectionInterval > 0 &&
+            (state.messageCount - state.lastInjectionMessageCount) >=
+                injectionInterval;
+        if (!shouldInjectOnFirst && !shouldReinject)
+            return;
+        if (shouldReinject) {
+            output.parts = removeSyntheticMemoryParts(output.parts);
+        }
+        try {
+            const prefix = shouldReinject ? "graphiti-refresh-" : "graphiti-memory-";
+            const useUserScope = shouldInjectOnFirst;
+            const characterBudget = (0, context_limit_js_1.calculateInjectionBudget)(state.contextLimit);
+            await injectMemoryContext(state, messageText, output, prefix, useUserScope, characterBudget);
+            state.injectedMemories = true;
+            state.lastInjectionMessageCount = state.messageCount;
+        }
+        catch (err) {
+            logger_js_1.logger.error("Failed to inject memories:", err);
+        }
+    };
+}

package/script/src/handlers/compacting.d.ts

@@ -0,0 +1,15 @@
+import type { GraphitiClient } from "../services/client.js";
+import type { SessionManager } from "../session.js";
+/** Dependencies for the compacting handler. */
+export interface CompactingHandlerDeps {
+    sessionManager: SessionManager;
+    client: GraphitiClient;
+    defaultGroupId: string;
+}
+/** Creates the `experimental.session.compacting` hook handler. */
+export declare function createCompactingHandler(deps: CompactingHandlerDeps): ({ sessionID }: {
+    sessionID: string;
+}, output: {
+    context: string[];
+}) => Promise<void>;
+//# sourceMappingURL=compacting.d.ts.map

package/script/src/handlers/compacting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compacting.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/compacting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAI5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,+CAA+C;AAC/C,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,cAAc,CAAC;IAC/B,MAAM,EAAE,cAAc,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,kEAAkE;AAClE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,qBAAqB,IAI/D,eAAe;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,EACpC,QAAQ;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,mBAyBhC"}

package/script/src/handlers/compacting.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompactingHandler = createCompactingHandler;
+const compaction_js_1 = require("../services/compaction.js");
+const context_limit_js_1 = require("../services/context-limit.js");
+const logger_js_1 = require("../services/logger.js");
+/** Creates the `experimental.session.compacting` hook handler. */
+function createCompactingHandler(deps) {
+    const { sessionManager, client, defaultGroupId } = deps;
+    return async ({ sessionID }, output) => {
+        const state = sessionManager.getState(sessionID);
+        if (!state?.isMain) {
+            logger_js_1.logger.debug("Ignoring non-main compaction context:", sessionID);
+            return;
+        }
+        const groupId = state.groupId || defaultGroupId;
+        const characterBudget = (0, context_limit_js_1.calculateInjectionBudget)(state.contextLimit);
+        const additionalContext = await (0, compaction_js_1.getCompactionContext)({
+            client,
+            characterBudget,
+            groupIds: {
+                project: groupId,
+                user: state.userGroupId,
+            },
+            contextStrings: output.context,
+        });
+        if (additionalContext.length > 0) {
+            output.context.push(...additionalContext);
+            logger_js_1.logger.info("Injected persistent knowledge into compaction context");
+        }
+    };
+}

package/script/src/handlers/event.d.ts

@@ -0,0 +1,18 @@
+import type { Event } from "@opencode-ai/sdk";
+import type { GraphitiClient } from "../services/client.js";
+import type { ProviderListClient } from "../services/context-limit.js";
+import type { SessionManager } from "../session.js";
+/** Dependencies for the event handler. */
+export interface EventHandlerDeps {
+    sessionManager: SessionManager;
+    client: GraphitiClient;
+    defaultGroupId: string;
+    sdkClient: ProviderListClient;
+    directory: string;
+    groupIdPrefix: string;
+}
+/** Creates the `event` hook handler. */
+export declare function createEventHandler(deps: EventHandlerDeps): ({ event }: {
+    event: Event;
+}) => Promise<void>;
+//# sourceMappingURL=event.d.ts.map

package/script/src/handlers/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,0CAA0C;AAC1C,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,MAAM,EAAE,cAAc,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,kBAAkB,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wCAAwC;AACxC,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,IAWzC,WAAW;IAAE,KAAK,EAAE,KAAK,CAAA;CAAE,mBA+J1C"}

package/script/src/handlers/event.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventHandler = createEventHandler;
+const compaction_js_1 = require("../services/compaction.js");
+const context_limit_js_1 = require("../services/context-limit.js");
+const logger_js_1 = require("../services/logger.js");
+const utils_js_1 = require("../utils.js");
+/** Creates the `event` hook handler. */
+function createEventHandler(deps) {
+    const { sessionManager, client, defaultGroupId, sdkClient, directory, groupIdPrefix, } = deps;
+    const defaultUserGroupId = (0, utils_js_1.makeUserGroupId)(groupIdPrefix);
+    return async ({ event }) => {
+        try {
+            if (event.type === "session.created") {
+                const info = event.properties.info;
+                const sessionId = info.id;
+                const parentId = info.parentID ?? null;
+                const isMain = !parentId;
+                sessionManager.setParentId(sessionId, parentId);
+                logger_js_1.logger.info("Session created:", {
+                    sessionId,
+                    isMain,
+                    parentID: info.parentID,
+                });
+                if (isMain) {
+                    sessionManager.setState(sessionId, {
+                        groupId: defaultGroupId,
+                        userGroupId: defaultUserGroupId,
+                        injectedMemories: false,
+                        lastInjectionMessageCount: 0,
+                        messageCount: 0,
+                        pendingMessages: [],
+                        contextLimit: 200_000,
+                        isMain,
+                    });
+                }
+                else {
+                    logger_js_1.logger.debug("Ignoring subagent session:", sessionId);
+                }
+                return;
+            }
+            if (event.type === "session.compacted") {
+                const sessionId = event.properties.sessionID;
+                const { state, resolved } = await sessionManager.resolveSessionState(sessionId);
+                if (!resolved) {
+                    logger_js_1.logger.debug("Unable to resolve session compaction:", sessionId);
+                    return;
+                }
+                if (!state?.isMain) {
+                    logger_js_1.logger.debug("Ignoring non-main compaction:", sessionId);
+                    return;
+                }
+                const summary = event.properties.summary ||
+                    "";
+                await sessionManager.flushPendingMessages(sessionId, "Buffered messages flushed before compaction", 0);
+                if (summary) {
+                    await (0, compaction_js_1.handleCompaction)({
+                        client,
+                        groupId: state.groupId,
+                        summary,
+                        sessionId,
+                    });
+                }
+                return;
+            }
+            if (event.type === "session.idle") {
+                const sessionId = event.properties.sessionID;
+                const { state, resolved } = await sessionManager.resolveSessionState(sessionId);
+                if (!resolved) {
+                    logger_js_1.logger.debug("Unable to resolve idle session:", sessionId);
+                    return;
+                }
+                if (!state?.isMain) {
+                    logger_js_1.logger.debug("Ignoring non-main idle session:", sessionId);
+                    return;
+                }
+                await sessionManager.flushPendingMessages(sessionId, "Buffered messages from OpenCode session", 50);
+                return;
+            }
+            if (event.type === "message.updated") {
+                const info = event.properties.info;
+                const sessionId = info.sessionID;
+                logger_js_1.logger.info("Message event fired", {
+                    hook: "message.updated",
+                    eventType: "message.updated",
+                    sessionId,
+                    role: info.role,
+                    messageID: info.id,
+                });
+                const { state, resolved } = await sessionManager.resolveSessionState(sessionId);
+                if (!resolved) {
+                    logger_js_1.logger.debug("Unable to resolve session for message update:", {
+                        sessionId,
+                        messageID: info.id,
+                        role: info.role,
+                    });
+                    return;
+                }
+                if (!state?.isMain) {
+                    logger_js_1.logger.debug("Ignoring non-main message update:", sessionId);
+                    return;
+                }
+                if (info.role !== "assistant") {
+                    sessionManager.deletePendingAssistant(sessionId, info.id);
+                    return;
+                }
+                const time = info.time;
+                if (!time?.completed)
+                    return;
+                if (sessionManager.isAssistantBuffered(sessionId, info.id))
+                    return;
+                sessionManager.finalizeAssistantMessage(state, sessionId, info.id, "message.updated");
+                if (info.tokens && info.providerID && info.modelID) {
+                    (0, context_limit_js_1.resolveContextLimit)(info.providerID, info.modelID, sdkClient, directory)
+                        .then((limit) => {
+                        state.contextLimit = limit;
+                    })
+                        .catch((err) => logger_js_1.logger.debug("Failed to resolve context limit", err));
+                }
+                return;
+            }
+            if (event.type === "message.part.updated") {
+                const part = event.properties.part;
+                if (!(0, utils_js_1.isTextPart)(part))
+                    return;
+                const sessionId = part.sessionID;
+                const messageId = part.messageID;
+                sessionManager.bufferAssistantPart(sessionId, messageId, part.text);
+            }
+        }
+        catch (err) {
+            logger_js_1.logger.error("Event handler error", { type: event.type, err });
+        }
+    };
+}

package/script/src/index.d.ts

@@ -1,4 +1,6 @@
 import type { Plugin } from "@opencode-ai/plugin";
-export declare const makeGroupId: (prefix: string, directory?: string) => string;
+/**
+ * OpenCode plugin entry point for Graphiti memory integration.
+ */
 export declare const graphiti: Plugin;
 //# sourceMappingURL=index.d.ts.map

package/script/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAqB/D,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,EAAE,YAAY,MAAM,KAAG,MAKhE,CAAC;AAeF,eAAO,MAAM,QAAQ,EAAE,MA+ftB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAW/D;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,MA4CtB,CAAC"}