opencode-graphiti 0.0.0-development

package/script/_dnt.shims.d.ts

@@ -0,0 +1,6 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/script/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAKvC,eAAO,MAAM,aAAa;;CAA2C,CAAC"}

package/script/_dnt.shims.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Deno = void 0;
+const shim_deno_1 = require("@deno/shim-deno");
+var shim_deno_2 = require("@deno/shim-deno");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+const dntGlobals = {
+    Deno: shim_deno_1.Deno,
+};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/deno.d.ts

@@ -0,0 +1,45 @@
+declare namespace _default {
+    export let name: string;
+    export let description: string;
+    export let version: string;
+    export let license: string;
+    export namespace tasks {
+        let build: string;
+        let check: string;
+        let deploy: string;
+        let dev: string;
+        let lint: string;
+        let fmt: string;
+    }
+    export namespace lint_1 {
+        let exclude: string[];
+        namespace rules {
+            let exclude_1: string[];
+            export { exclude_1 as exclude };
+        }
+    }
+    export { lint_1 as lint };
+    export namespace fmt_1 {
+        let exclude_2: string[];
+        export { exclude_2 as exclude };
+    }
+    export { fmt_1 as fmt };
+    export namespace compilerOptions {
+        let strict: boolean;
+        let lib: string[];
+    }
+    export let nodeModulesDir: string;
+    export let imports: {
+        "@modelcontextprotocol/sdk": string;
+        "@opencode-ai/plugin": string;
+        "@opencode-ai/sdk": string;
+        cosmiconfig: string;
+        ioredis: string;
+        zod: string;
+    };
+    export let exports: {
+        ".": string;
+    };
+}
+export default _default;
+//# sourceMappingURL=deno.d.ts.map

package/script/deno.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno.d.ts","sourceRoot":"","sources":["../src/deno.js"],"names":[],"mappings":""}

package/script/deno.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    "name": "opencode-graphiti",
+    "description": "OpenCode plugin for persistent memory via Graphiti knowledge graph",
+    "version": "0.0.0-development",
+    "license": "MIT",
+    "tasks": {
+        "build": "deno run -A dnt.ts",
+        "check": "deno check src/index.ts",
+        "deploy": "deno eval \"throw new Error('Manual publish is disabled. Use the GitHub Actions publish workflow for releases.')\"",
+        "dev": "deno run --allow-all src/index.ts",
+        "lint": "deno lint",
+        "fmt": "deno fmt"
+    },
+    "lint": {
+        "exclude": ["dist/"],
+        "rules": {
+            "exclude": ["no-import-prefix"]
+        }
+    },
+    "fmt": {
+        "exclude": ["dist/"]
+    },
+    "compilerOptions": {
+        "strict": true,
+        "lib": ["deno.ns", "dom", "esnext"]
+    },
+    "nodeModulesDir": "auto",
+    "imports": {
+        "@modelcontextprotocol/sdk": "npm:@modelcontextprotocol/sdk@^1.25.2",
+        "@opencode-ai/plugin": "npm:@opencode-ai/plugin@1.2.26",
+        "@opencode-ai/sdk": "npm:@opencode-ai/sdk@1.2.26",
+        "cosmiconfig": "npm:cosmiconfig@9.0.0",
+        "ioredis": "npm:ioredis@^5.7.0",
+        "zod": "npm:zod@4.3.6"
+    },
+    "exports": {
+        ".": "./mod.ts"
+    }
+};

package/script/mod.d.ts

@@ -0,0 +1,3 @@
+import "./_dnt.polyfills.js";
+export { graphiti } from "./src/index.js";
+//# sourceMappingURL=mod.d.ts.map

package/script/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAC7B,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC"}

package/script/mod.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphiti = void 0;
+require("./_dnt.polyfills.js");
+var index_js_1 = require("./src/index.js");
+Object.defineProperty(exports, "graphiti", { enumerable: true, get: function () { return index_js_1.graphiti; } });

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/src/config.d.ts

@@ -0,0 +1,20 @@
+import type { GraphitiConfig } from "./types/index.js";
+type ConfigLoadResult = {
+    config: unknown;
+} | null;
+export declare class ConfigLoadError extends Error {
+    cause: unknown;
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface ConfigExplorerAdapter {
+    search(from?: string): ConfigLoadResult;
+    load(filePath: string): ConfigLoadResult;
+}
+type ConfigExplorerFactory = () => ConfigExplorerAdapter;
+export declare const setConfigExplorerAdapterForTesting: (factory: ConfigExplorerFactory) => void;
+export declare const resetConfigExplorerAdapterForTesting: () => void;
+export declare function loadConfig(directory?: string): GraphitiConfig;
+export {};
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/src/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AA8BvD,KAAK,gBAAgB,GAAG;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAAC;AAMnD,qBAAa,eAAgB,SAAQ,KAAK;IAC/B,KAAK,EAAE,OAAO,CAAC;gBAEZ,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAK3D;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACxC,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAAC;CAC1C;AAED,KAAK,qBAAqB,GAAG,MAAM,qBAAqB,CAAC;AAmNzD,eAAO,MAAM,kCAAkC,GAC7C,SAAS,qBAAqB,KAC7B,IAEF,CAAC;AAEF,eAAO,MAAM,oCAAoC,QAAO,IAEvD,CAAC;AAuEF,wBAAgB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,cAAc,CAO7D"}

package/script/src/config.js

@@ -0,0 +1,256 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetConfigExplorerAdapterForTesting = exports.setConfigExplorerAdapterForTesting = exports.ConfigLoadError = void 0;
+exports.loadConfig = loadConfig;
+const node_os_1 = __importDefault(require("node:os"));
+const node_module_1 = require("node:module");
+const node_path_1 = require("node:path");
+const DEFAULT_CONFIG = {
+    redis: {
+        endpoint: "redis://localhost:6379",
+        batchSize: 20,
+        batchMaxBytes: 51_200,
+        sessionTtlSeconds: 86_400,
+        cacheTtlSeconds: 600,
+        drainRetryMax: 3,
+    },
+    graphiti: {
+        endpoint: "http://localhost:8000/mcp",
+        groupIdPrefix: "opencode",
+        driftThreshold: 0.5,
+    },
+    endpoint: "http://localhost:8000/mcp",
+    groupIdPrefix: "opencode",
+    driftThreshold: 0.5,
+};
+class ConfigLoadError extends Error {
+    constructor(message, options) {
+        super(message);
+        Object.defineProperty(this, "cause", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "ConfigLoadError";
+        this.cause = options?.cause;
+    }
+}
+exports.ConfigLoadError = ConfigLoadError;
+const require = (0, node_module_1.createRequire)(globalThis[Symbol.for("import-meta-ponyfill-commonjs")](require, module).url);
+const isRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const readString = (value, key) => typeof value[key] === "string" ? value[key] : undefined;
+const readNumber = (value, key) => typeof value[key] === "number" ? value[key] : undefined;
+const normalizeConfig = (value) => {
+    if (!isRecord(value))
+        return {};
+    const compact = (input) => Object.fromEntries(Object.entries(input).filter(([_, entry]) => entry !== undefined));
+    const config = {
+        endpoint: readString(value, "endpoint"),
+        groupIdPrefix: readString(value, "groupIdPrefix"),
+        driftThreshold: readNumber(value, "driftThreshold"),
+    };
+    if (isRecord(value.redis)) {
+        config.redis = compact({
+            endpoint: readString(value.redis, "endpoint"),
+            batchSize: readNumber(value.redis, "batchSize"),
+            batchMaxBytes: readNumber(value.redis, "batchMaxBytes"),
+            sessionTtlSeconds: readNumber(value.redis, "sessionTtlSeconds"),
+            cacheTtlSeconds: readNumber(value.redis, "cacheTtlSeconds"),
+            drainRetryMax: readNumber(value.redis, "drainRetryMax"),
+        });
+    }
+    if (isRecord(value.falkordb)) {
+        config.falkordb = compact({
+            redisEndpoint: readString(value.falkordb, "redisEndpoint"),
+            batchSize: readNumber(value.falkordb, "batchSize"),
+            batchMaxBytes: readNumber(value.falkordb, "batchMaxBytes"),
+            sessionTtlSeconds: readNumber(value.falkordb, "sessionTtlSeconds"),
+            cacheTtlSeconds: readNumber(value.falkordb, "cacheTtlSeconds"),
+            drainRetryMax: readNumber(value.falkordb, "drainRetryMax"),
+        });
+    }
+    if (isRecord(value.graphiti)) {
+        config.graphiti = compact({
+            endpoint: readString(value.graphiti, "endpoint"),
+            groupIdPrefix: readString(value.graphiti, "groupIdPrefix"),
+            driftThreshold: readNumber(value.graphiti, "driftThreshold"),
+        });
+    }
+    return config;
+};
+const isPositiveInteger = (value) => typeof value === "number" && Number.isInteger(value) && value > 0;
+const isUnitInterval = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 &&
+    value <= 1;
+const isValidUrlString = (value) => {
+    if (!value?.trim())
+        return false;
+    try {
+        new URL(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const assertExplicitUrl = (value, fieldName) => {
+    if (value === undefined)
+        return;
+    if (isValidUrlString(value))
+        return;
+    throw new ConfigLoadError(`Invalid Graphiti config value for ${fieldName}: expected a valid URL`);
+};
+const validateExplicitConfig = (value) => {
+    if (!value)
+        return;
+    assertExplicitUrl(value.endpoint, "endpoint");
+    assertExplicitUrl(value.graphiti?.endpoint, "graphiti.endpoint");
+    assertExplicitUrl(value.redis?.endpoint, "redis.endpoint");
+    assertExplicitUrl(value.falkordb?.redisEndpoint, "falkordb.redisEndpoint");
+};
+const resolveNumber = (...candidates) => candidates.find((value) => value !== undefined);
+const resolveConfig = (value) => {
+    const raw = value ?? {};
+    const resolvedRedisEndpoint = raw.redis?.endpoint ??
+        raw.falkordb?.redisEndpoint ??
+        DEFAULT_CONFIG.redis.endpoint;
+    const resolvedBatchSize = resolveNumber(raw.redis?.batchSize, raw.falkordb?.batchSize);
+    const resolvedBatchMaxBytes = resolveNumber(raw.redis?.batchMaxBytes, raw.falkordb?.batchMaxBytes);
+    const resolvedSessionTtlSeconds = resolveNumber(raw.redis?.sessionTtlSeconds, raw.falkordb?.sessionTtlSeconds);
+    const resolvedCacheTtlSeconds = resolveNumber(raw.redis?.cacheTtlSeconds, raw.falkordb?.cacheTtlSeconds);
+    const resolvedDrainRetryMax = resolveNumber(raw.redis?.drainRetryMax, raw.falkordb?.drainRetryMax);
+    const requestedGraphitiEndpoint = raw.graphiti?.endpoint ?? raw.endpoint;
+    const resolvedGraphitiEndpoint = isValidUrlString(requestedGraphitiEndpoint)
+        ? requestedGraphitiEndpoint
+        : DEFAULT_CONFIG.graphiti.endpoint;
+    const resolvedGroupIdPrefix = raw.graphiti?.groupIdPrefix ??
+        raw.groupIdPrefix ??
+        DEFAULT_CONFIG.graphiti.groupIdPrefix;
+    const resolvedDriftThreshold = resolveNumber(raw.graphiti?.driftThreshold, raw.driftThreshold);
+    const redis = {
+        endpoint: resolvedRedisEndpoint,
+        batchSize: isPositiveInteger(resolvedBatchSize)
+            ? resolvedBatchSize
+            : DEFAULT_CONFIG.redis.batchSize,
+        batchMaxBytes: isPositiveInteger(resolvedBatchMaxBytes)
+            ? resolvedBatchMaxBytes
+            : DEFAULT_CONFIG.redis.batchMaxBytes,
+        sessionTtlSeconds: isPositiveInteger(resolvedSessionTtlSeconds)
+            ? resolvedSessionTtlSeconds
+            : DEFAULT_CONFIG.redis.sessionTtlSeconds,
+        cacheTtlSeconds: isPositiveInteger(resolvedCacheTtlSeconds)
+            ? resolvedCacheTtlSeconds
+            : DEFAULT_CONFIG.redis.cacheTtlSeconds,
+        drainRetryMax: isPositiveInteger(resolvedDrainRetryMax)
+            ? resolvedDrainRetryMax
+            : DEFAULT_CONFIG.redis.drainRetryMax,
+    };
+    const falkordb = {
+        redisEndpoint: redis.endpoint,
+        batchSize: redis.batchSize,
+        batchMaxBytes: redis.batchMaxBytes,
+        sessionTtlSeconds: redis.sessionTtlSeconds,
+        cacheTtlSeconds: redis.cacheTtlSeconds,
+        drainRetryMax: redis.drainRetryMax,
+    };
+    const graphiti = {
+        endpoint: resolvedGraphitiEndpoint,
+        groupIdPrefix: resolvedGroupIdPrefix,
+        driftThreshold: isUnitInterval(resolvedDriftThreshold)
+            ? resolvedDriftThreshold
+            : DEFAULT_CONFIG.graphiti.driftThreshold,
+    };
+    return {
+        redis,
+        falkordb,
+        graphiti,
+        endpoint: graphiti.endpoint,
+        groupIdPrefix: graphiti.groupIdPrefix,
+        driftThreshold: graphiti.driftThreshold,
+    };
+};
+const createCosmiconfigAdapter = () => {
+    const { cosmiconfigSync } = require("cosmiconfig");
+    const explorer = cosmiconfigSync("graphiti", { searchStrategy: "global" });
+    return {
+        search(from) {
+            return explorer.search(from);
+        },
+        load(filePath) {
+            return explorer.load(filePath);
+        },
+    };
+};
+let configExplorerFactory = createCosmiconfigAdapter;
+const setConfigExplorerAdapterForTesting = (factory) => {
+    configExplorerFactory = factory;
+};
+exports.setConfigExplorerAdapterForTesting = setConfigExplorerAdapterForTesting;
+const resetConfigExplorerAdapterForTesting = () => {
+    configExplorerFactory = createCosmiconfigAdapter;
+};
+exports.resetConfigExplorerAdapterForTesting = resetConfigExplorerAdapterForTesting;
+const getConfigExplorerAdapter = () => {
+    try {
+        return configExplorerFactory();
+    }
+    catch (err) {
+        throw new ConfigLoadError("Unable to initialize Graphiti config discovery", { cause: err });
+    }
+};
+const loadConfigFile = (adapter, filePath) => {
+    try {
+        const loaded = adapter?.load(filePath);
+        const normalized = loaded ? normalizeConfig(loaded.config) : null;
+        validateExplicitConfig(normalized);
+        return normalized;
+    }
+    catch (err) {
+        if (err instanceof ConfigLoadError)
+            throw err;
+        throw new ConfigLoadError(`Unable to load Graphiti config file: ${filePath}`, { cause: err });
+    }
+};
+const getHomeDir = () => {
+    try {
+        return node_os_1.default.homedir();
+    }
+    catch {
+        return undefined;
+    }
+};
+const searchConfig = (adapter, directory) => {
+    try {
+        const loaded = adapter.search(directory);
+        const normalized = loaded ? normalizeConfig(loaded.config) : null;
+        validateExplicitConfig(normalized);
+        return {
+            ok: true,
+            config: normalized,
+        };
+    }
+    catch (err) {
+        if (err instanceof ConfigLoadError)
+            throw err;
+        throw new ConfigLoadError("Unable to discover Graphiti config", {
+            cause: err,
+        });
+    }
+};
+const loadLegacyConfig = (adapter) => {
+    const homeDir = getHomeDir();
+    if (!homeDir)
+        return null;
+    return loadConfigFile(adapter, (0, node_path_1.join)(homeDir, ".config", "opencode", ".graphitirc"));
+};
+function loadConfig(directory) {
+    const adapter = getConfigExplorerAdapter();
+    const searched = searchConfig(adapter, directory);
+    const loaded = searched.ok ? searched.config : null;
+    const resolved = loaded ?? loadLegacyConfig(adapter);
+    validateExplicitConfig(resolved);
+    return resolveConfig(resolved);
+}

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

@@ -0,0 +1,14 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { GraphitiAsyncService } from "../services/graphiti-async.js";
+import type { RedisEventsService } from "../services/redis-events.js";
+import type { SessionManager } from "../session.js";
+type ChatMessageHook = NonNullable<Hooks["chat.message"]>;
+export interface ChatHandlerDeps {
+    sessionManager: SessionManager;
+    redisEvents: RedisEventsService;
+    graphitiAsync: GraphitiAsyncService;
+    drainTriggerSize: number;
+}
+export declare function createChatHandler(deps: ChatHandlerDeps): ChatMessageHook;
+export {};
+//# sourceMappingURL=chat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chat.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/chat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAE1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAGtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,KAAK,eAAe,GAAG,WAAW,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;AAI1D,MAAM,WAAW,eAAe;IAC9B,cAAc,EAAE,cAAc,CAAC;IAC/B,WAAW,EAAE,kBAAkB,CAAC;IAChC,aAAa,EAAE,oBAAoB,CAAC;IACpC,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAmExE"}

package/script/src/handlers/chat.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChatHandler = createChatHandler;
+const event_extractor_js_1 = require("../services/event-extractor.js");
+const logger_js_1 = require("../services/logger.js");
+const render_utils_js_1 = require("../services/render-utils.js");
+const utils_js_1 = require("../utils.js");
+function createChatHandler(deps) {
+    const { sessionManager, redisEvents, graphitiAsync, drainTriggerSize } = deps;
+    return async ({ sessionID }, output) => {
+        try {
+            sessionManager.markSessionActive(sessionID);
+            const { state, resolved, canonicalSessionId } = await sessionManager
+                .resolveSessionState(sessionID);
+            if (!resolved || !state?.isMain)
+                return;
+            if (!canonicalSessionId)
+                return;
+            sessionManager.markResolvedSessionActive(sessionID, canonicalSessionId);
+            const messageText = (0, utils_js_1.extractTextFromParts)(output.parts);
+            if (!messageText)
+                return;
+            const sanitizedMessageText = (0, render_utils_js_1.sanitizeMemoryInput)(messageText);
+            if (!sanitizedMessageText)
+                return;
+            state.messageCount += 1;
+            state.latestUserRequest = sanitizedMessageText;
+            state.latestRefreshQuery = sanitizedMessageText;
+            let queueLength = 0;
+            for (const event of (0, event_extractor_js_1.extractStructuredEvents)({
+                eventType: "chat.message",
+                sessionId: sessionID,
+                messageText: sanitizedMessageText,
+                messageCount: state.messageCount,
+                role: "user",
+            })) {
+                queueLength = await redisEvents.recordEvent(canonicalSessionId, state.groupId, event);
+            }
+            const prepared = await sessionManager.prepareInjection(canonicalSessionId, sanitizedMessageText);
+            if (prepared) {
+                state.injectedMemories = true;
+            }
+            logger_js_1.logger.info("Prepared local session memory for chat transform", {
+                sessionID: canonicalSessionId,
+                sourceSessionID: sessionID,
+                hotTierReady: state.hotTierReady,
+                refreshClassification: prepared?.refreshDecision.classification,
+            });
+            if (prepared && prepared.refreshDecision.shouldRefresh) {
+                graphitiAsync.scheduleCacheRefresh(state.groupId, sanitizedMessageText);
+            }
+            if (queueLength >= drainTriggerSize) {
+                graphitiAsync.scheduleDrain(state.groupId);
+            }
+        }
+        catch (error) {
+            logger_js_1.logger.warn("Unable to prepare local session memory for chat transform", {
+                sessionID,
+                error,
+            });
+        }
+    };
+}

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

@@ -0,0 +1,9 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { SessionManager } from "../session.js";
+type CompactingHook = NonNullable<Hooks["experimental.session.compacting"]>;
+export interface CompactingHandlerDeps {
+    sessionManager: SessionManager;
+}
+export declare function createCompactingHandler(deps: CompactingHandlerDeps): CompactingHook;
+export {};
+//# 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,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,KAAK,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,iCAAiC,CAAC,CAAC,CAAC;AAI5E,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,cAAc,CAAC;CAChC;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,qBAAqB,GAC1B,cAAc,CAmChB"}

package/script/src/handlers/compacting.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompactingHandler = createCompactingHandler;
+const logger_js_1 = require("../services/logger.js");
+function createCompactingHandler(deps) {
+    const { sessionManager } = deps;
+    return async ({ sessionID }, output) => {
+        try {
+            const { state, resolved, canonicalSessionId, } = await sessionManager.resolveSessionState(sessionID);
+            if (!resolved || !canonicalSessionId)
+                return;
+            if (!state?.isMain)
+                return;
+            sessionManager.markResolvedSessionActive(sessionID, canonicalSessionId);
+            const prepared = await sessionManager.prepareInjection(canonicalSessionId);
+            if (!prepared?.envelope)
+                return;
+            output.context.push(prepared.envelope);
+            sessionManager.clearPendingInjection(state, prepared);
+            logger_js_1.logger.info("Injected local session_memory into compaction context", {
+                sessionID: canonicalSessionId,
+                sourceSessionID: sessionID,
+                hotTierReady: state.hotTierReady,
+            });
+        }
+        catch (error) {
+            logger_js_1.logger.warn("Unable to prepare local session memory for compaction", {
+                sessionID,
+                error,
+            });
+        }
+    };
+}

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

@@ -0,0 +1,22 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { GraphitiAsyncService } from "../services/graphiti-async.js";
+import type { RedisCacheService } from "../services/redis-cache.js";
+import type { RedisEventsService } from "../services/redis-events.js";
+import type { RedisSnapshotService } from "../services/redis-snapshot.js";
+import type { SessionManager } from "../session.js";
+type EventHook = NonNullable<Hooks["event"]>;
+export interface EventHandlerDeps {
+    sessionManager: SessionManager;
+    redisEvents: RedisEventsService;
+    redisCache: RedisCacheService;
+    redisSnapshot: RedisSnapshotService;
+    graphitiAsync: GraphitiAsyncService;
+    defaultGroupId: string;
+    defaultUserGroupId: string;
+    sdkClient: OpencodeClient;
+    directory: string;
+}
+export declare function createEventHandler(deps: EventHandlerDeps): EventHook;
+export {};
+//# 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,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAE1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,KAAK,SAAS,GAAG,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;AAG7C,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,WAAW,EAAE,kBAAkB,CAAC;IAChC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,aAAa,EAAE,oBAAoB,CAAC;IACpC,aAAa,EAAE,oBAAoB,CAAC;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,cAAc,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;AAmDD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,SAAS,CAoXpE"}