opencode-graphiti 0.0.0-development

package/esm/_dnt.polyfills.js

@@ -0,0 +1,177 @@
+function findLastIndex(self, callbackfn, that) {
+    const boundFunc = that === undefined ? callbackfn : callbackfn.bind(that);
+    let index = self.length - 1;
+    while (index >= 0) {
+        const result = boundFunc(self[index], index, self);
+        if (result) {
+            return index;
+        }
+        index--;
+    }
+    return -1;
+}
+function findLast(self, callbackfn, that) {
+    const index = self.findLastIndex(callbackfn, that);
+    return index === -1 ? undefined : self[index];
+}
+if (!Array.prototype.findLastIndex) {
+    Array.prototype.findLastIndex = function (callbackfn, that) {
+        return findLastIndex(this, callbackfn, that);
+    };
+}
+if (!Array.prototype.findLast) {
+    Array.prototype.findLast = function (callbackfn, that) {
+        return findLast(this, callbackfn, that);
+    };
+}
+if (!Uint8Array.prototype.findLastIndex) {
+    Uint8Array.prototype.findLastIndex = function (callbackfn, that) {
+        return findLastIndex(this, callbackfn, that);
+    };
+}
+if (!Uint8Array.prototype.findLast) {
+    Uint8Array.prototype.findLast = function (callbackfn, that) {
+        return findLast(this, callbackfn, that);
+    };
+}
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+//@ts-ignore
+import { createRequire } from "node:module";
+//@ts-ignore
+import { fileURLToPath, pathToFileURL } from "node:url";
+//@ts-ignore
+import { dirname } from "node:path";
+const defineGlobalPonyfill = (symbolFor, fn) => {
+    if (!Reflect.has(globalThis, Symbol.for(symbolFor))) {
+        Object.defineProperty(globalThis, Symbol.for(symbolFor), {
+            configurable: true,
+            get() {
+                return fn;
+            },
+        });
+    }
+};
+export let import_meta_ponyfill_commonjs = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-commonjs")) ??
+    (() => {
+        const moduleImportMetaWM = new WeakMap();
+        return (require, module) => {
+            let importMetaCache = moduleImportMetaWM.get(module);
+            if (importMetaCache == null) {
+                const importMeta = Object.assign(Object.create(null), {
+                    url: pathToFileURL(module.filename).href,
+                    main: require.main == module,
+                    resolve: (specifier, parentURL = importMeta.url) => {
+                        return pathToFileURL((importMeta.url === parentURL
+                            ? require
+                            : createRequire(parentURL))
+                            .resolve(specifier)).href;
+                    },
+                    filename: module.filename,
+                    dirname: module.path,
+                });
+                moduleImportMetaWM.set(module, importMeta);
+                importMetaCache = importMeta;
+            }
+            return importMetaCache;
+        };
+    })());
+defineGlobalPonyfill("import-meta-ponyfill-commonjs", import_meta_ponyfill_commonjs);
+export let import_meta_ponyfill_esmodule = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-esmodule")) ??
+    ((importMeta) => {
+        const resolveFunStr = String(importMeta.resolve);
+        const shimWs = new WeakSet();
+        //@ts-ignore
+        const mainUrl = ("file:///" + process.argv[1].replace(/\\/g, "/"))
+            .replace(/\/{3,}/, "///");
+        const commonShim = (importMeta) => {
+            if (typeof importMeta.main !== "boolean") {
+                importMeta.main = importMeta.url === mainUrl;
+            }
+            if (typeof importMeta.filename !== "string") {
+                importMeta.filename = fileURLToPath(importMeta.url);
+                importMeta.dirname = dirname(importMeta.filename);
+            }
+        };
+        if (
+        // v16.2.0+, v14.18.0+: Add support for WHATWG URL object to parentURL parameter.
+        resolveFunStr === "undefined" ||
+            // v20.0.0+, v18.19.0+"" This API now returns a string synchronously instead of a Promise.
+            resolveFunStr.startsWith("async")
+        // enable by --experimental-import-meta-resolve flag
+        ) {
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    const importMetaUrlRequire = {
+                        url: importMeta.url,
+                        require: createRequire(importMeta.url),
+                    };
+                    importMeta.resolve = function resolve(specifier, parentURL = importMeta.url) {
+                        return pathToFileURL((importMetaUrlRequire.url === parentURL
+                            ? importMetaUrlRequire.require
+                            : createRequire(parentURL)).resolve(specifier)).href;
+                    };
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        else {
+            /// native support
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        return import_meta_ponyfill_esmodule(importMeta);
+    }));
+defineGlobalPonyfill("import-meta-ponyfill-esmodule", import_meta_ponyfill_esmodule);
+export let import_meta_ponyfill = ((...args) => {
+    const _MODULE = (() => {
+        if (typeof require === "function" && typeof module === "object") {
+            return "commonjs";
+        }
+        else {
+            // eval("typeof import.meta");
+            return "esmodule";
+        }
+    })();
+    if (_MODULE === "commonjs") {
+        //@ts-ignore
+        import_meta_ponyfill = (r, m) => import_meta_ponyfill_commonjs(r, m);
+    }
+    else {
+        //@ts-ignore
+        import_meta_ponyfill = (im) => import_meta_ponyfill_esmodule(im);
+    }
+    //@ts-ignore
+    return import_meta_ponyfill(...args);
+});

package/esm/_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/esm/_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/esm/_dnt.shims.js

@@ -0,0 +1,61 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+const dntGlobals = {
+    Deno,
+};
+export const 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/esm/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/esm/deno.d.ts.map

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

package/esm/deno.js

@@ -0,0 +1,39 @@
+export 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/esm/mod.d.ts

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

package/esm/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/esm/mod.js

@@ -0,0 +1,2 @@
+import "./_dnt.polyfills.js";
+export { graphiti } from "./src/index.js";

package/esm/package.json

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

package/esm/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/esm/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/esm/src/config.js

@@ -0,0 +1,246 @@
+import os from "node:os";
+import { createRequire } from "node:module";
+import { join } from "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,
+};
+export 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;
+    }
+}
+const require = createRequire(globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).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;
+export const setConfigExplorerAdapterForTesting = (factory) => {
+    configExplorerFactory = factory;
+};
+export const resetConfigExplorerAdapterForTesting = () => {
+    configExplorerFactory = createCosmiconfigAdapter;
+};
+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 os.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, join(homeDir, ".config", "opencode", ".graphitirc"));
+};
+export 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/esm/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/esm/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"}