opencode-graphiti 0.1.0

package/esm/src/index.js

@@ -0,0 +1,436 @@
+import { loadConfig } from "./config.js";
+import { GraphitiClient } from "./services/client.js";
+import { createPreemptiveCompactionHandler, getCompactionContext, handleCompaction, } from "./services/compaction.js";
+import { formatMemoryContext } from "./services/context.js";
+import { logger } from "./services/logger.js";
+export const makeGroupId = (prefix, directory) => {
+    const parts = directory?.split("/").filter(Boolean) ?? [];
+    const projectName = parts[parts.length - 1] || "default";
+    const rawGroupId = `${prefix}_${projectName}`;
+    return rawGroupId.replace(/[^A-Za-z0-9_-]/g, "_");
+};
+const isTextPart = (value) => {
+    if (!value || typeof value !== "object")
+        return false;
+    const part = value;
+    return part.type === "text" && typeof part.text === "string" &&
+        !part.synthetic;
+};
+const extractTextFromParts = (parts) => parts.filter(isTextPart).map((part) => part.text).join(" ").trim();
+export const graphiti = async (input) => {
+    const config = loadConfig();
+    const client = new GraphitiClient(config.endpoint);
+    const sdkClient = input.client;
+    const connected = await client.connect();
+    if (!connected) {
+        logger.warn("Could not connect to Graphiti MCP server at", config.endpoint);
+        logger.warn("Memory features will be unavailable until connection is established");
+    }
+    const defaultGroupId = makeGroupId(config.groupIdPrefix, input.directory);
+    logger.info("Plugin initialized. Group ID:", defaultGroupId);
+    const sessions = new Map();
+    const parentIdCache = new Map();
+    const pendingAssistantMessages = new Map();
+    const bufferedAssistantMessageIds = new Set();
+    const resolveParentId = async (sessionId) => {
+        if (parentIdCache.has(sessionId)) {
+            return parentIdCache.get(sessionId) ?? null;
+        }
+        try {
+            const response = await sdkClient.session.get({
+                path: { id: sessionId },
+            });
+            const sessionInfo = typeof response === "object" && response !== null &&
+                "data" in response
+                ? response.data
+                : response;
+            if (!sessionInfo)
+                return undefined;
+            const parentId = sessionInfo.parentID ?? null;
+            parentIdCache.set(sessionId, parentId);
+            return parentId;
+        }
+        catch (err) {
+            logger.debug("Failed to resolve session parentID", { sessionId, err });
+            return undefined;
+        }
+    };
+    const resolveSessionState = async (sessionId) => {
+        const parentId = await resolveParentId(sessionId);
+        if (parentId === undefined)
+            return { state: null, resolved: false };
+        if (parentId) {
+            sessions.delete(sessionId);
+            return { state: null, resolved: true };
+        }
+        let state = sessions.get(sessionId);
+        if (!state) {
+            state = {
+                groupId: defaultGroupId,
+                injectedMemories: false,
+                messageCount: 0,
+                pendingMessages: [],
+                isMain: true,
+            };
+            sessions.set(sessionId, state);
+        }
+        return { state, resolved: true };
+    };
+    const isSubagentSession = async (sessionId) => {
+        const parentId = await resolveParentId(sessionId);
+        return !!parentId;
+    };
+    const fetchLatestAssistantMessage = async (sessionId) => {
+        try {
+            const response = await sdkClient.session.messages({
+                sessionID: sessionId,
+                limit: 20,
+            });
+            const payload = response && typeof response === "object" &&
+                "data" in response
+                ? response.data
+                : response;
+            const messages = Array.isArray(payload)
+                ? payload
+                : [];
+            if (messages.length === 0)
+                return null;
+            const lastAssistant = [...messages]
+                .reverse()
+                .find((message) => message.info?.role === "assistant");
+            if (!lastAssistant)
+                return null;
+            const text = extractTextFromParts(lastAssistant.parts);
+            if (!text)
+                return null;
+            return { id: lastAssistant.info?.id, text };
+        }
+        catch (err) {
+            logger.debug("Failed to list session messages for fallback", {
+                sessionId,
+                err,
+            });
+            return null;
+        }
+    };
+    const finalizeAssistantMessage = (state, sessionId, messageId, source) => {
+        const key = `${sessionId}:${messageId}`;
+        if (bufferedAssistantMessageIds.has(key))
+            return;
+        const buffered = pendingAssistantMessages.get(key);
+        pendingAssistantMessages.delete(key);
+        bufferedAssistantMessageIds.add(key);
+        const messageText = buffered?.text?.trim() ?? "";
+        const messagePreview = messageText.slice(0, 120);
+        logger.info("Assistant message completed", {
+            hook: source,
+            sessionId,
+            messageID: messageId,
+            source,
+            messageLength: messageText.length,
+            preview: messagePreview,
+        });
+        if (!messageText) {
+            logger.debug("Assistant message completed without buffered text", {
+                hook: source,
+                sessionId,
+                messageID: messageId,
+                source,
+            });
+            return;
+        }
+        state.pendingMessages.push(`Assistant: ${messageText}`);
+        logger.info("Buffered assistant reply", {
+            hook: source,
+            sessionId,
+            messageID: messageId,
+            source,
+            messageLength: messageText.length,
+            preview: messagePreview,
+        });
+    };
+    const flushPendingMessages = async (sessionId, sourceDescription, minBytes) => {
+        const state = sessions.get(sessionId);
+        if (!state || state.pendingMessages.length === 0)
+            return;
+        const lastMessage = state.pendingMessages.at(-1);
+        if (lastMessage) {
+            const separatorIndex = lastMessage.indexOf(":");
+            const role = separatorIndex === -1
+                ? lastMessage.trim().toLowerCase()
+                : lastMessage.slice(0, separatorIndex).trim().toLowerCase();
+            if (role === "user") {
+                const fallback = await fetchLatestAssistantMessage(sessionId);
+                if (fallback?.text) {
+                    const fallbackKey = fallback.id
+                        ? `${sessionId}:${fallback.id}`
+                        : undefined;
+                    const alreadyBuffered = fallbackKey
+                        ? bufferedAssistantMessageIds.has(fallbackKey)
+                        : state.pendingMessages.some((message) => message.startsWith("Assistant:") &&
+                            message.includes(fallback.text));
+                    if (!alreadyBuffered) {
+                        state.pendingMessages.push(`Assistant: ${fallback.text}`);
+                        if (fallbackKey) {
+                            bufferedAssistantMessageIds.add(fallbackKey);
+                        }
+                        logger.info("Fallback assistant fetch used", {
+                            sessionId,
+                            messageID: fallback.id,
+                            messageLength: fallback.text.length,
+                        });
+                    }
+                }
+            }
+        }
+        const combined = state.pendingMessages.join("\n\n");
+        if (combined.length < minBytes)
+            return;
+        const messagesToFlush = [...state.pendingMessages];
+        state.pendingMessages = [];
+        const messageLines = messagesToFlush.map((message) => {
+            const separatorIndex = message.indexOf(":");
+            const role = separatorIndex === -1
+                ? "Unknown"
+                : message.slice(0, separatorIndex).trim();
+            const text = separatorIndex === -1
+                ? message
+                : message.slice(separatorIndex + 1).trim();
+            return `${role}: ${text}`;
+        });
+        try {
+            const name = combined.slice(0, 80).replace(/\n/g, " ");
+            logger.info(`Flushing ${messagesToFlush.length} buffered message(s).`);
+            logger.info(`Buffered message contents:\n${messageLines.join("\n")}`, { sessionId });
+            await client.addEpisode({
+                name: `Buffered messages: ${name}`,
+                episodeBody: combined,
+                groupId: state.groupId,
+                source: "text",
+                sourceDescription,
+            });
+            logger.info("Flushed buffered messages to Graphiti");
+        }
+        catch (err) {
+            logger.error(`Failed to flush messages for ${sessionId}:`, err);
+            const currentState = sessions.get(sessionId);
+            if (currentState) {
+                currentState.pendingMessages = [
+                    ...messagesToFlush,
+                    ...currentState.pendingMessages,
+                ];
+            }
+        }
+    };
+    const preemptiveCompaction = createPreemptiveCompactionHandler({
+        compactionThreshold: config.compactionThreshold,
+        minTokensForCompaction: config.minTokensForCompaction,
+        compactionCooldownMs: config.compactionCooldownMs,
+        autoResumeAfterCompaction: config.autoResumeAfterCompaction,
+    }, {
+        sdkClient: sdkClient,
+        directory: input.directory,
+    });
+    return {
+        event: 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;
+                    parentIdCache.set(sessionId, parentId);
+                    logger.info("Session created:", {
+                        sessionId,
+                        isMain,
+                        parentID: info.parentID,
+                    });
+                    if (isMain) {
+                        sessions.set(sessionId, {
+                            groupId: defaultGroupId,
+                            injectedMemories: false,
+                            messageCount: 0,
+                            pendingMessages: [],
+                            isMain,
+                        });
+                    }
+                    else {
+                        logger.debug("Ignoring subagent session:", sessionId);
+                    }
+                    return;
+                }
+                if (event.type === "session.compacted") {
+                    const sessionId = event.properties.sessionID;
+                    const { state, resolved } = await resolveSessionState(sessionId);
+                    if (!resolved) {
+                        logger.debug("Unable to resolve session compaction:", sessionId);
+                        return;
+                    }
+                    if (!state?.isMain) {
+                        logger.debug("Ignoring non-main compaction:", sessionId);
+                        return;
+                    }
+                    const summary = event.properties.summary ||
+                        "";
+                    await flushPendingMessages(sessionId, "Buffered messages flushed before compaction", 0);
+                    if (summary) {
+                        await handleCompaction({
+                            client,
+                            config,
+                            groupId: state.groupId,
+                            summary,
+                            sessionId,
+                        });
+                    }
+                    return;
+                }
+                if (event.type === "session.idle") {
+                    const sessionId = event.properties.sessionID;
+                    const { state, resolved } = await resolveSessionState(sessionId);
+                    if (!resolved) {
+                        logger.debug("Unable to resolve idle session:", sessionId);
+                        return;
+                    }
+                    if (!state?.isMain) {
+                        logger.debug("Ignoring non-main idle session:", sessionId);
+                        return;
+                    }
+                    await flushPendingMessages(sessionId, "Buffered messages from OpenCode session", 50);
+                    return;
+                }
+                if (event.type === "message.updated") {
+                    const info = event.properties.info;
+                    const sessionId = info.sessionID;
+                    logger.info("Message event fired", {
+                        hook: "message.updated",
+                        eventType: "message.updated",
+                        sessionId,
+                        role: info.role,
+                        messageID: info.id,
+                    });
+                    const { state, resolved } = await resolveSessionState(sessionId);
+                    if (!resolved) {
+                        logger.debug("Unable to resolve session for message update:", {
+                            sessionId,
+                            messageID: info.id,
+                            role: info.role,
+                        });
+                        return;
+                    }
+                    if (!state?.isMain) {
+                        logger.debug("Ignoring non-main message update:", sessionId);
+                        return;
+                    }
+                    if (info.role !== "assistant") {
+                        pendingAssistantMessages.delete(`${sessionId}:${info.id}`);
+                        return;
+                    }
+                    const key = `${sessionId}:${info.id}`;
+                    const time = info.time;
+                    if (!time?.completed)
+                        return;
+                    if (bufferedAssistantMessageIds.has(key))
+                        return;
+                    finalizeAssistantMessage(state, sessionId, info.id, "message.updated");
+                    if (info.tokens && info.providerID && info.modelID) {
+                        preemptiveCompaction
+                            .checkAndTriggerCompaction(sessionId, info.tokens, info.providerID, info.modelID)
+                            .catch((err) => logger.error("Preemptive compaction check failed", err));
+                    }
+                    return;
+                }
+                if (event.type === "message.part.updated") {
+                    const part = event.properties.part;
+                    if (part.type !== "text" || part.synthetic)
+                        return;
+                    const sessionId = part.sessionID;
+                    const messageId = part.messageID;
+                    const key = `${sessionId}:${messageId}`;
+                    pendingAssistantMessages.set(key, {
+                        sessionId,
+                        text: part.text,
+                    });
+                }
+            }
+            catch (err) {
+                logger.error("Event handler error", { type: event.type, err });
+            }
+        },
+        "chat.message": async ({ sessionID }, output) => {
+            if (await isSubagentSession(sessionID)) {
+                logger.debug("Ignoring subagent chat message:", sessionID);
+                return;
+            }
+            const { state, resolved } = await resolveSessionState(sessionID);
+            if (!resolved) {
+                output.allow_buffering = true;
+                logger.debug("Unable to resolve session for message:", { sessionID });
+                return;
+            }
+            if (!state?.isMain) {
+                logger.debug("Ignoring subagent chat message:", sessionID);
+                return;
+            }
+            state.messageCount++;
+            const messageText = extractTextFromParts(output.parts);
+            if (!messageText)
+                return;
+            state.pendingMessages.push(`User: ${messageText}`);
+            logger.info("Buffered user message", {
+                hook: "chat.message",
+                sessionID,
+                messageLength: messageText.length,
+            });
+            if (!state.injectedMemories && config.injectOnFirstMessage) {
+                state.injectedMemories = true;
+                try {
+                    const [facts, nodes] = await Promise.all([
+                        client.searchFacts({
+                            query: messageText,
+                            groupIds: [state.groupId],
+                            maxFacts: config.maxFacts,
+                        }),
+                        client.searchNodes({
+                            query: messageText,
+                            groupIds: [state.groupId],
+                            maxNodes: config.maxNodes,
+                        }),
+                    ]);
+                    const memoryContext = formatMemoryContext(facts, nodes);
+                    if (memoryContext) {
+                        output.parts.unshift({
+                            type: "text",
+                            text: memoryContext,
+                            id: `graphiti-memory-${Date.now()}`,
+                            sessionID: output.message.sessionID,
+                            messageID: output.message.id,
+                            synthetic: true,
+                        });
+                        logger.info(`Injected ${facts.length} facts and ${nodes.length} nodes`);
+                    }
+                }
+                catch (err) {
+                    logger.error("Failed to inject memories:", err);
+                }
+            }
+        },
+        "experimental.session.compacting": async ({ sessionID }, output) => {
+            const state = sessions.get(sessionID);
+            if (!state?.isMain) {
+                logger.debug("Ignoring non-main compaction context:", sessionID);
+                return;
+            }
+            const groupId = state.groupId || defaultGroupId;
+            const additionalContext = await getCompactionContext({
+                client,
+                config,
+                groupId,
+                contextStrings: output.context,
+            });
+            if (additionalContext.length > 0) {
+                output.context.push(...additionalContext);
+                logger.info("Injected persistent knowledge into compaction context");
+            }
+        },
+    };
+};

package/esm/src/services/client.d.ts

@@ -0,0 +1,37 @@
+import type { GraphitiEpisode, GraphitiFact, GraphitiNode } from "../types/index.js";
+export declare class GraphitiClient {
+    private client;
+    private transport;
+    private connected;
+    private endpoint;
+    constructor(endpoint: string);
+    connect(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    private callTool;
+    private isSessionExpired;
+    private reconnect;
+    parseToolResult(result: unknown): unknown;
+    addEpisode(params: {
+        name: string;
+        episodeBody: string;
+        groupId?: string;
+        source?: "text" | "json" | "message";
+        sourceDescription?: string;
+    }): Promise<void>;
+    searchFacts(params: {
+        query: string;
+        groupIds?: string[];
+        maxFacts?: number;
+    }): Promise<GraphitiFact[]>;
+    searchNodes(params: {
+        query: string;
+        groupIds?: string[];
+        maxNodes?: number;
+    }): Promise<GraphitiNode[]>;
+    getEpisodes(params: {
+        groupIds?: string[];
+        maxEpisodes?: number;
+    }): Promise<GraphitiEpisode[]>;
+    getStatus(): Promise<boolean>;
+}
+//# sourceMappingURL=client.d.ts.map

package/esm/src/services/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/src/services/client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EAEZ,YAAY,EAEb,MAAM,mBAAmB,CAAC;AAG3B,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAgC;IACjD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,EAAE,MAAM;IAStB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAa3B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAOnB,QAAQ;IAkCtB,OAAO,CAAC,gBAAgB;YASV,SAAS;IAgBvB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO;IAyBnC,UAAU,CAAC,MAAM,EAAE;QACvB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;QACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,GAAG,OAAO,CAAC,IAAI,CAAC;IAWX,WAAW,CAAC,MAAM,EAAE;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAsBrB,WAAW,CAAC,MAAM,EAAE;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAsBrB,WAAW,CAAC,MAAM,EAAE;QACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAaxB,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;CAQpC"}

package/esm/src/services/client.js

@@ -0,0 +1,201 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { logger } from "./logger.js";
+export class GraphitiClient {
+    constructor(endpoint) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "transport", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connected", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "endpoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.endpoint = endpoint;
+        this.client = new Client({ name: "opencode-graphiti", version: "0.1.0" });
+        const url = new dntShim.dntGlobalThis.URL(endpoint);
+        this.transport = new StreamableHTTPClientTransport(url);
+    }
+    async connect() {
+        if (this.connected)
+            return true;
+        try {
+            await this.client.connect(this.transport);
+            this.connected = true;
+            logger.info("Connected to Graphiti MCP server at", this.endpoint);
+            return true;
+        }
+        catch (err) {
+            logger.error("Failed to connect to Graphiti:", err);
+            return false;
+        }
+    }
+    async disconnect() {
+        if (this.connected) {
+            await this.client.close();
+            this.connected = false;
+        }
+    }
+    async callTool(name, args) {
+        if (!this.connected) {
+            const ok = await this.connect();
+            if (!ok)
+                throw new Error("Not connected to Graphiti");
+        }
+        // Sanitize arguments: omit task_id (and others) if null or undefined
+        const sanitizedArgs = Object.fromEntries(Object.entries(args).filter(([_, v]) => v !== null && v !== undefined));
+        try {
+            const result = await this.client.callTool({
+                name,
+                arguments: sanitizedArgs,
+            });
+            return this.parseToolResult(result);
+        }
+        catch (err) {
+            if (this.isSessionExpired(err)) {
+                logger.warn("Graphiti session expired, reconnecting...");
+                await this.reconnect();
+                const result = await this.client.callTool({
+                    name,
+                    arguments: sanitizedArgs,
+                });
+                return this.parseToolResult(result);
+            }
+            throw err;
+        }
+    }
+    isSessionExpired(err) {
+        return !!(err &&
+            typeof err === "object" &&
+            "code" in err &&
+            err.code === 404);
+    }
+    async reconnect() {
+        this.connected = false;
+        try {
+            await this.transport.close();
+        }
+        catch {
+            // ignore transport close errors
+        }
+        this.transport = new StreamableHTTPClientTransport(new URL(this.endpoint));
+        await this.client.connect(this.transport);
+        this.connected = true;
+        logger.info("Reconnected to Graphiti MCP server");
+    }
+    // Public for testing
+    parseToolResult(result) {
+        const typedResult = result;
+        const content = typedResult.content;
+        if (!Array.isArray(content) || content.length === 0)
+            return result;
+        const text = content.find((item) => item?.type === "text")?.text;
+        if (text === undefined)
+            return result;
+        if (typeof text !== "string") {
+            try {
+                return JSON.parse(String(text));
+            }
+            catch {
+                return text;
+            }
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    async addEpisode(params) {
+        await this.callTool("add_memory", {
+            name: params.name,
+            episode_body: params.episodeBody,
+            group_id: params.groupId,
+            source: params.source || "text",
+            source_description: params.sourceDescription || "",
+        });
+        logger.debug("Added episode:", params.name);
+    }
+    async searchFacts(params) {
+        try {
+            const result = await this.callTool("search_memory_facts", {
+                query: params.query,
+                group_ids: params.groupIds,
+                max_facts: params.maxFacts || 10,
+            });
+            if (Array.isArray(result))
+                return result;
+            if (result &&
+                typeof result === "object" &&
+                Array.isArray(result.facts)) {
+                return result.facts;
+            }
+            return [];
+        }
+        catch (err) {
+            logger.error("searchFacts error:", err);
+            return [];
+        }
+    }
+    async searchNodes(params) {
+        try {
+            const result = await this.callTool("search_nodes", {
+                query: params.query,
+                group_ids: params.groupIds,
+                max_nodes: params.maxNodes || 10,
+            });
+            if (Array.isArray(result))
+                return result;
+            if (result &&
+                typeof result === "object" &&
+                Array.isArray(result.nodes)) {
+                return result.nodes;
+            }
+            return [];
+        }
+        catch (err) {
+            logger.error("searchNodes error:", err);
+            return [];
+        }
+    }
+    async getEpisodes(params) {
+        try {
+            const result = await this.callTool("get_episodes", {
+                group_ids: params.groupIds,
+                max_episodes: params.maxEpisodes || 10,
+            });
+            return result || [];
+        }
+        catch (err) {
+            logger.error("getEpisodes error:", err);
+            return [];
+        }
+    }
+    async getStatus() {
+        try {
+            await this.callTool("get_status", {});
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}