opencode-graphiti 0.0.0-development

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vicary
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,358 @@
+# opencode-graphiti
+
+OpenCode plugin that gives your AI agent **short-term memory** and **long-term
+memory**.
+
+**Short-term memory** continuously summarizes and compacts every meaningful
+session event — decisions, active tasks, file edits, errors, and more — into a
+priority-tiered snapshot that is re-injected before every LLM call and every
+compaction. The result is a rolling window of session continuity that
+effectively extends the usable context far beyond the model's native limit: the
+agent always knows what it was doing, even after the conversation is compacted.
+
+**Long-term memory** persists knowledge across sessions via a
+[Graphiti](https://github.com/getzep/graphiti) knowledge graph, so the agent can
+recall project facts, past decisions, and learned preferences from earlier work
+— not just the current session.
+
+## Motivation
+
+Long-running AI coding sessions depend on persistent memory to stay on track.
+When the context window fills up and OpenCode triggers compaction, the
+summarizer discards details that were never captured outside the conversation.
+The result is **context rot**: the agent loses track of recent decisions,
+re-explores solved problems, and drifts away from the original goal.
+
+Graphiti's MCP server is a powerful knowledge-graph backend, but calling it on
+every message adds latency and introduces a single point of failure —
+connections drop, queries time out, and ingestion silently fails.
+
+This plugin exists to close both gaps.
+
+**Short-term memory** captures every meaningful event during the session —
+decisions, task progress, file edits, errors, environment changes — and
+continuously summarizes them into a compact, priority-tiered snapshot. That
+snapshot is re-injected before every LLM call and before every compaction, so
+the agent always retains a coherent picture of the active workstream. Because
+the snapshot is continuously rebuilt from structured events rather than raw
+conversation text, it survives compaction intact: the model picks up exactly
+where it left off, no matter how many times the conversation has been
+summarized. In practice, this creates a rolling session memory that extends the
+effective context window well beyond the model's native limit.
+
+**Long-term memory** lives in Graphiti's knowledge graph, which is updated in
+the background so it never slows down your conversation. It provides
+cross-session recall — project facts, past decisions, and learned preferences
+from earlier sessions — cached locally for instant injection alongside the
+short-term snapshot.
+
+## Overview
+
+This plugin uses a two-layer memory architecture:
+
+**Short-term memory — continuously summarized session continuity:**
+
+- Captures every meaningful event (decisions, tasks, file edits, errors,
+  environment changes) as structured session events
+- Continuously rebuilds a priority-tiered snapshot from those events, keeping
+  the most important context within a tight budget
+- Re-injects the snapshot before every LLM call and every compaction as a
+  `<session_memory>` block, so the agent never loses track of the active
+  workstream — even after repeated compactions
+- Detects topic drift and schedules a background refresh of cached long-term
+  facts when the conversation shifts
+
+**Long-term memory — persistent cross-session recall via Graphiti:**
+
+- Sends buffered session events to Graphiti as episodes on idle or before
+  compaction
+- Refreshes the local memory cache from Graphiti search results in the
+  background
+- Provides cross-session recall via vector/graph search, cached locally for
+  instant injection alongside the short-term snapshot
+- Saves compaction summaries as episodes so knowledge survives across session
+  boundaries
+
+Graphiti stays off the steady-state hook path entirely: hook-time injection uses
+only Redis/local cached recall, while fresh Graphiti data arrives through the
+existing background refresh path on later turns.
+
+## Prerequisites
+
+Start the
+[Graphiti MCP server](https://github.com/getzep/graphiti/tree/main/mcp_server)
+with its default [FalkorDB](https://www.falkordb.com/) backend:
+
+```bash
+git clone https://github.com/getzep/graphiti.git
+cd graphiti/mcp_server
+docker compose up -d
+```
+
+This starts Graphiti at `http://localhost:8000/mcp` and FalkorDB/Redis on
+`localhost:6379`.
+
+This plugin reuses that same FalkorDB/Redis storage layer alongside Graphiti: it
+keeps short-term memory locally for every turn, while Graphiti builds the
+long-term knowledge graph on top of the same backend.
+
+> **Note:** Graphiti is optional for basic operation. If Graphiti is
+> unavailable, the plugin continues to function with FalkorDB/Redis-sourced
+> session memory; only the `<persistent_memory>` section (long-term
+> cross-session facts) will be empty until Graphiti comes online.
+
+## Installation
+
+### Option A: npm package (recommended)
+
+Add the plugin to your `opencode.json` (or `opencode.jsonc`):
+
+```jsonc
+{
+  "plugin": ["opencode-graphiti"]
+}
+```
+
+### Option B: Local build
+
+Local distributable builds are not a routine local setup step: `deno task
+build`
+requires an explicit `VERSION` via `dnt.ts`. If you already have a built
+artifact, add it to your `opencode.json`:
+
+```jsonc
+{
+  "plugin": ["file:///absolute/path/to/opencode-graphiti/dist/esm/mod.js"]
+}
+```
+
+### Option C: Plugin directory
+
+Copy the built plugin into OpenCode's auto-loaded plugin directory:
+
+```bash
+# Global (all projects)
+cp dist/esm/mod.js ~/.config/opencode/plugins/opencode-graphiti.js
+
+# Or project-level
+mkdir -p .opencode/plugins
+cp dist/esm/mod.js .opencode/plugins/opencode-graphiti.js
+```
+
+No config entry needed — OpenCode loads plugins from these directories
+automatically.
+
+## Configuration
+
+Supported config locations, in lookup order:
+
+1. The provided project directory: `package.json#graphiti`, `.graphitirc`, and
+   other standard `cosmiconfig` `graphiti` filenames
+2. Standard global/home `graphiti` config locations discovered by `cosmiconfig`
+   (for example `~/.graphitirc`)
+3. Legacy fallback: `~/.config/opencode/.graphitirc`
+
+### Nested Config Shape (recommended)
+
+```jsonc
+{
+  "redis": {
+    // Redis endpoint used for the plugin hot tier
+    "endpoint": "redis://localhost:6379",
+    // Max events per drain batch
+    "batchSize": 20,
+    // Max combined body bytes per drain batch
+    "batchMaxBytes": 51200,
+    // Session event TTL in seconds (default: 24 h)
+    "sessionTtlSeconds": 86400,
+    // Memory cache TTL in seconds (default: 10 min)
+    "cacheTtlSeconds": 600,
+    // Max drain retry attempts before dead-lettering
+    "drainRetryMax": 3
+  },
+  "graphiti": {
+    // Graphiti MCP server endpoint
+    "endpoint": "http://localhost:8000/mcp",
+    // Prefix for project group IDs (e.g. "opencode-my-project")
+    "groupIdPrefix": "opencode",
+    // Jaccard similarity threshold (0–1) below which cache is refreshed
+    "driftThreshold": 0.5
+  }
+}
+```
+
+All fields are optional — defaults (shown above) are used for any missing
+values. Canonical nested values take precedence when both forms are supplied.
+
+### Retained Compatibility
+
+The canonical hot-tier config shape is now `redis.*`. For backward
+compatibility, the loader still accepts legacy nested `falkordb.*` values. Only
+the original Graphiti top-level aliases remain supported. Precedence is:
+
+1. `redis.*` (canonical)
+2. `falkordb.*` (legacy nested compatibility)
+3. top-level Graphiti aliases such as `endpoint` and `groupIdPrefix`
+
+### Legacy Top-Level Keys
+
+For backward compatibility, the following original Graphiti top-level keys are
+still accepted and map to their nested equivalents:
+
+| Legacy key       | Nested equivalent         |
+| ---------------- | ------------------------- |
+| `endpoint`       | `graphiti.endpoint`       |
+| `groupIdPrefix`  | `graphiti.groupIdPrefix`  |
+| `driftThreshold` | `graphiti.driftThreshold` |
+
+Legacy nested `falkordb.*` keys remain accepted as compatibility aliases for the
+same `redis.*` settings. Removed top-level Redis aliases are no longer
+supported.
+
+## How It Works
+
+### Injection Format
+
+The plugin currently injects a `<session_memory>` XML envelope into the last
+user message. This envelope is assembled from short-term memory in Redis and can
+contain structured sections such as `<last_request>`, `<active_tasks>`,
+`<key_decisions>`, `<files_in_play>`, `<project_rules>`, and an optional
+`<session_snapshot>`.
+
+When long-term memory is available, a nested `<persistent_memory>` section is
+included with a `node_refs` attribute naming the emitted cached entities. On a
+cold first turn or when Graphiti is unreachable, `<persistent_memory>` is simply
+absent — the rest of the session memory is always available from short-term
+storage in FalkorDB/Redis.
+
+```xml
+<session_memory source="falkordb+graphiti-cache" version="1">
+  <last_request>Continue the current task.</last_request>
+  <active_tasks><task>Implement the new feature.</task></active_tasks>
+  <key_decisions><decision>Use Redis for short-term memory.</decision></key_decisions>
+  <files_in_play><file>src/index.ts</file></files_in_play>
+  <project_rules><rule>Graphiti runs in the background only.</rule></project_rules>
+  <session_snapshot><!-- priority-tiered snapshot --></session_snapshot>
+  <persistent_memory node_refs="nodeA">
+    <!-- long-term node/episode summaries from Graphiti, optional -->
+  </persistent_memory>
+</session_memory>
+```
+
+### Session Memory Preparation (`chat.message`)
+
+On each user message the plugin assembles the current session memory from three
+sources:
+
+- Recent structured session events
+- The continuously rebuilt priority-tiered snapshot
+- Cached long-term facts from Graphiti
+
+These are composed into a `<session_memory>` envelope and staged for the
+transform hook. The hook-time reads are local/cache-backed only; any fresh
+Graphiti lookup remains on the existing background refresh path and benefits the
+next turn instead of blocking the current one.
+
+### User Message Injection (`experimental.chat.messages.transform`)
+
+The transform hook reads the prepared `<session_memory>` envelope and prepends
+it to the last user message. Legacy `<memory data-uuids>` and older
+`<persistent_memory fact_uuids>` blocks are still scrubbed and parsed for
+compatibility, while current `<persistent_memory>` output uses `node_refs`. This
+approach keeps the system prompt static, enabling provider-side prefix caching,
+and avoids influencing session titles. The prepared injection is cleared after
+use so stale context is not re-injected on subsequent LLM calls within the same
+turn.
+
+### Drift Detection and Background Cache Refresh
+
+On each user message, the plugin compares the current query against the query
+that produced the cached memory. When Jaccard similarity between the current
+query text and cached query text drops below `driftThreshold` (default 0.5), a
+background cache refresh is scheduled via Graphiti. The current cached context
+is still injected immediately; the refreshed cache becomes available on the next
+message. This trades one message of staleness for keeping most long-term memory
+refresh work off the response-time path.
+
+### Event Extraction and Buffering (`event`)
+
+User and assistant messages are captured as structured `SessionEvent` objects
+and stored in Redis (`session:{id}:events`). The plugin listens on
+`message.part.updated` to buffer assistant text as it streams, and on
+`message.updated` to finalize completed assistant replies.
+
+Events are also queued for background ingestion into long-term memory:
+
+- **On idle** (`session.idle`): buffered events are sent to Graphiti and the
+  priority-tiered snapshot is rebuilt.
+- **Before compaction** (`session.compacted`): all pending events are sent
+  immediately so nothing is lost.
+
+### Compaction Preservation
+
+Compaction is handled entirely by OpenCode's native compaction mechanism. The
+plugin ensures session continuity survives each compaction cycle:
+
+1. **Before compaction** (`experimental.session.compacting`): The plugin injects
+   the same `<session_memory>` envelope used for chat — including the
+   priority-tiered snapshot and cached long-term facts — so the summarizer
+   preserves important knowledge. No Graphiti call is made.
+2. **After compaction** (`session.compacted`): The snapshot is rebuilt from
+   structured events and the compaction summary is sent to Graphiti in the
+   background, ensuring knowledge survives across compaction boundaries.
+
+Because the snapshot is rebuilt from structured events rather than raw
+conversation text, the agent retains a coherent picture of the workstream
+regardless of how aggressively the conversation was summarized.
+
+### Child / Subagent Session Handling
+
+> **Note:** This behavior intentionally diverges from
+> [context-mode](https://github.com/mksglu/context-mode), which records subagent
+> work as summarized tool events. This plugin promotes child sessions to
+> first-class participants in the root session's state so that decisions, file
+> edits, and errors from delegated work are fully visible to the parent session.
+> See `plans/ContextOverhaul.md` §10.1 for the design rationale.
+
+When OpenCode spawns a child session (e.g. a subagent or delegated task), the
+plugin resolves the child's `sessionID` to the root/parent session by walking
+the `parentID` chain. All event storage, snapshot builds, and `<session_memory>`
+injection then operate on the canonical root session, so child activity is
+treated identically to parent activity:
+
+- Child prompts and responses are recorded in the same event log as the parent.
+- The priority-tiered snapshot includes child-derived events when it is rebuilt.
+- Future `<session_memory>` injections — for both parent and child turns —
+  reflect the combined activity of the entire session lineage.
+- Deleting a child session removes only that child's local bookkeeping; the root
+  session's state, events, and snapshot are preserved.
+
+This means the agent retains full continuity across delegation boundaries
+without any special configuration.
+
+### Project Scoping
+
+Each project gets a unique `group_id` derived from its directory name (e.g.
+`opencode_my-project`). Group IDs only allow letters, numbers, dashes, and
+underscores (colons are not allowed). This ensures memories from different
+projects stay isolated.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and release
+process. In CI, pushes to `main` publish `latest` releases, while pull requests
+targeting `main` publish canary builds under the `canary` dist-tag.
+
+## License
+
+MIT
+
+## Acknowledgements
+
+The structured event extraction, priority-tiered snapshots, and session
+continuity design in this plugin are inspired by
+[context-mode](https://github.com/mksglu/context-mode) by
+[Mert Köseoğlu](https://github.com/mksglu).
+
+The original plugin concept is inspired by
+[opencode-openmemory](https://github.com/happycastle114/opencode-openmemory).

package/esm/_dnt.polyfills.d.ts

@@ -0,0 +1,166 @@
+declare global {
+    interface Array<T> {
+        /**
+         * Returns the value of the last element in the array where predicate is true, and undefined
+         * otherwise.
+         * @param predicate find calls predicate once for each element of the array, in ascending
+         * order, until it finds one where predicate returns true. If such an element is found, find
+         * immediately returns that element value. Otherwise, find returns undefined.
+         * @param thisArg If provided, it will be used as the this value for each invocation of
+         * predicate. If it is not provided, undefined is used instead.
+         */
+        findLast<S extends T>(predicate: (this: void, value: T, index: number, obj: T[]) => value is S, thisArg?: any): S | undefined;
+        findLast(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
+        /**
+         * Returns the index of the last element in the array where predicate is true, and -1
+         * otherwise.
+         * @param predicate find calls predicate once for each element of the array, in ascending
+         * order, until it finds one where predicate returns true. If such an element is found,
+         * findIndex immediately returns that element index. Otherwise, findIndex returns -1.
+         * @param thisArg If provided, it will be used as the this value for each invocation of
+         * predicate. If it is not provided, undefined is used instead.
+         */
+        findLastIndex(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): number;
+    }
+    interface Uint8Array {
+        /**
+         * Returns the value of the last element in the array where predicate is true, and undefined
+         * otherwise.
+         * @param predicate findLast calls predicate once for each element of the array, in descending
+         * order, until it finds one where predicate returns true. If such an element is found, findLast
+         * immediately returns that element value. Otherwise, findLast returns undefined.
+         * @param thisArg If provided, it will be used as the this value for each invocation of
+         * predicate. If it is not provided, undefined is used instead.
+         */
+        findLast<S extends number>(predicate: (value: number, index: number, array: Uint8Array) => value is S, thisArg?: any): S | undefined;
+        findLast(predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number | undefined;
+        /**
+         * Returns the index of the last element in the array where predicate is true, and -1
+         * otherwise.
+         * @param predicate findLastIndex calls predicate once for each element of the array, in descending
+         * order, until it finds one where predicate returns true. If such an element is found,
+         * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
+         * @param thisArg If provided, it will be used as the this value for each invocation of
+         * predicate. If it is not provided, undefined is used instead.
+         */
+        findLastIndex(predicate: (value: number, index: number, array: Uint8Array) => unknown, thisArg?: any): number;
+    }
+}
+export {};
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};
+declare global {
+    interface Error {
+        cause?: unknown;
+    }
+}
+export {};
+/**
+ * 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.
+ */
+import { createRequire } from "node:module";
+import { type URL } from "node:url";
+declare global {
+    interface ImportMeta {
+        /** A string representation of the fully qualified module URL. When the
+         * module is loaded locally, the value will be a file URL (e.g.
+         * `file:///path/module.ts`).
+         *
+         * You can also parse the string as a URL to determine more information about
+         * how the current module was loaded. For example to determine if a module was
+         * local or not:
+         *
+         * ```ts
+         * const url = new URL(import.meta.url);
+         * if (url.protocol === "file:") {
+         *   console.log("this module was loaded locally");
+         * }
+         * ```
+         */
+        url: string;
+        /**
+         * A function that returns resolved specifier as if it would be imported
+         * using `import(specifier)`.
+         *
+         * ```ts
+         * console.log(import.meta.resolve("./foo.js"));
+         * // file:///dev/foo.js
+         * ```
+         *
+         * @param specifier The module specifier to resolve relative to `parent`.
+         * @param parent The absolute parent module URL to resolve from.
+         * @returns The absolute (`file:`) URL string for the resolved module.
+         */
+        resolve(specifier: string, parent?: string | URL | undefined): string;
+        /** A flag that indicates if the current module is the main module that was
+         * called when starting the program under Deno.
+         *
+         * ```ts
+         * if (import.meta.main) {
+         *   // this was loaded as the main module, maybe do some bootstrapping
+         * }
+         * ```
+         */
+        main: boolean;
+        /** The absolute path of the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.filename); // /home/alice/my_module.ts
+         *
+         * // Windows
+         * console.log(import.meta.filename); // C:\alice\my_module.ts
+         * ```
+         */
+        filename: string;
+        /** The absolute path of the directory containing the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.dirname); // /home/alice
+         *
+         * // Windows
+         * console.log(import.meta.dirname); // C:\alice
+         * ```
+         */
+        dirname: string;
+    }
+}
+type NodeRequest = ReturnType<typeof createRequire>;
+type NodeModule = NonNullable<NodeRequest["main"]>;
+interface ImportMetaPonyfillCommonjs {
+    (require: NodeRequest, module: NodeModule): ImportMeta;
+}
+interface ImportMetaPonyfillEsmodule {
+    (importMeta: ImportMeta): ImportMeta;
+}
+interface ImportMetaPonyfill extends ImportMetaPonyfillCommonjs, ImportMetaPonyfillEsmodule {
+}
+export declare let import_meta_ponyfill_commonjs: ImportMetaPonyfillCommonjs;
+export declare let import_meta_ponyfill_esmodule: ImportMetaPonyfillEsmodule;
+export declare let import_meta_ponyfill: ImportMetaPonyfill;
+//# sourceMappingURL=_dnt.polyfills.d.ts.map

package/esm/_dnt.polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.polyfills.d.ts","sourceRoot":"","sources":["../src/_dnt.polyfills.ts"],"names":[],"mappings":"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"}