opencode-graphiti 0.1.0

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,176 @@
+# opencode-graphiti
+
+OpenCode plugin that provides persistent memory via a
+[Graphiti](https://github.com/getzep/graphiti) knowledge graph.
+
+## Motivation
+
+Long-running AI coding sessions depend on persistent memory to stay on track.
+Graphiti's MCP server is the intended backbone for this, but in practice it is
+unreliable — connections drop, queries time out, and ingestion silently fails.
+When the context window fills up and OpenCode triggers compaction, the
+summarizer discards details that were never persisted. The result is **context
+rot**: the agent loses track of recent decisions, re-explores solved problems,
+and drifts away from the original goal.
+
+This plugin exists to close that gap. It captures chat histories and project
+facts into Graphiti when the server is healthy, then **re-injects them at the
+start of every session and before every compaction** so the agent is always
+reminded of recent project context — regardless of what survived the summary.
+
+## Overview
+
+This plugin connects to a Graphiti MCP server and:
+
+- Injects relevant memories into the first user message of each session
+- Detects user-triggered memory saves ("remember this", "keep in mind", etc.)
+- Preserves key facts during context compaction
+- Scopes memories per project using directory-based group IDs
+
+## Prerequisites
+
+A running
+[Graphiti MCP server](https://github.com/getzep/graphiti/tree/main/mcp_server)
+accessible over HTTP. The easiest way to set one up:
+
+```bash
+# Clone and start with Docker Compose
+git clone https://github.com/getzep/graphiti.git
+cd graphiti/mcp_server
+docker compose up -d
+```
+
+This starts the MCP server at `http://localhost:8000/mcp` with a FalkorDB
+backend.
+
+## Installation
+
+### Option A: npm package (recommended)
+
+Add the plugin to your `opencode.json` (or `opencode.jsonc`):
+
+```jsonc
+{
+  "plugin": ["opencode-graphiti"]
+}
+```
+
+### Option B: Local build
+
+Clone and build, then reference the built file:
+
+```bash
+git clone https://github.com/vicary/opencode-graphiti.git
+cd opencode-graphiti
+deno task build
+```
+
+Then add to your `opencode.json`:
+
+```jsonc
+{
+  "plugin": ["file:///absolute/path/to/opencode-graphiti/dist/index.js"]
+}
+```
+
+### Option C: Plugin directory
+
+Copy the built plugin into OpenCode's auto-loaded plugin directory:
+
+```bash
+# Global (all projects)
+cp dist/index.js ~/.config/opencode/plugins/opencode-graphiti.js
+
+# Or project-level
+mkdir -p .opencode/plugins
+cp dist/index.js .opencode/plugins/opencode-graphiti.js
+```
+
+No config entry needed — OpenCode loads plugins from these directories
+automatically.
+
+## Configuration
+
+Create a config file at `~/.config/opencode/graphiti.jsonc`:
+
+```jsonc
+{
+  // Graphiti MCP server endpoint
+  "endpoint": "http://localhost:8000/mcp",
+
+  // Prefix for project group IDs (e.g. "opencode_my-project")
+  "groupIdPrefix": "opencode",
+
+  // Maximum results to retrieve
+  "maxFacts": 10,
+  "maxNodes": 5,
+  "maxEpisodes": 5,
+
+  // Feature toggles
+  "injectOnFirstMessage": true,
+  "enableTriggerDetection": true,
+  "enableCompactionSave": true
+}
+```
+
+All fields are optional — defaults are used for any missing values.
+
+## How It Works
+
+### Memory Injection (`chat.message`)
+
+On the first user message in a session, the plugin searches Graphiti for facts
+and entities relevant to the message content. Matching results are formatted and
+prepended to the conversation as a synthetic context block.
+
+### Trigger Detection (`chat.message`)
+
+User messages are scanned for phrases like:
+
+- "remember this", "memorize that"
+- "save this in memory", "keep this in mind"
+- "don't forget", "note this"
+- "for future reference"
+
+When detected, the message content is saved as an episode in Graphiti.
+
+### Compaction Preservation (`event` + `experimental.session.compacting`)
+
+When OpenCode compacts the context window:
+
+1. **Before compaction**: The plugin injects known facts into the compaction
+   context, so the summarizer preserves important knowledge.
+2. **After compaction**: If a summary is produced, it is saved as an episode to
+   Graphiti, ensuring knowledge survives across compaction boundaries.
+
+### 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.
+
+## Development
+
+```bash
+# Format
+deno fmt
+
+# Lint
+deno lint
+
+# Type check
+deno check src/index.ts
+
+# Build
+deno task build
+```
+
+## License
+
+MIT
+
+## Acknowledgement
+
+This project is inspired by
+[opencode-openmemory](https://github.com/happycastle114/opencode-openmemory)

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/mod.d.ts

@@ -0,0 +1,2 @@
+export * 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,cAAc,gBAAgB,CAAC"}

package/esm/mod.js

@@ -0,0 +1 @@
+export * from "./src/index.js";

package/esm/package.json

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

package/esm/src/config.d.ts

@@ -0,0 +1,3 @@
+import type { GraphitiConfig } from "./types/index.js";
+export declare function loadConfig(): GraphitiConfig;
+//# 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":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AA0BvD,wBAAgB,UAAU,IAAI,cAAc,CAe3C"}

package/esm/src/config.js

@@ -0,0 +1,43 @@
+import * as dntShim from "../_dnt.shims.js";
+import { cosmiconfigSync } from "cosmiconfig";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const DEFAULT_CONFIG = {
+    endpoint: "http://localhost:8000/mcp",
+    groupIdPrefix: "opencode",
+    maxFacts: 10,
+    maxNodes: 5,
+    maxEpisodes: 5,
+    injectOnFirstMessage: true,
+    enableCompactionSave: true,
+    compactionThreshold: 0.8,
+    minTokensForCompaction: 50000,
+    compactionCooldownMs: 30000,
+    autoResumeAfterCompaction: true,
+};
+function parseJsonc(text) {
+    let stripped = text.replace(/(^|\s)\/\/.*$/gm, "$1");
+    stripped = stripped.replace(/\/\*[\s\S]*?\*\//g, "");
+    return JSON.parse(stripped);
+}
+const createExplorer = (cwd) => {
+    return cosmiconfigSync("graphiti", { stopDir: cwd });
+};
+export function loadConfig() {
+    const cwd = dntShim.Deno.cwd();
+    const explorer = createExplorer(cwd);
+    const result = explorer.search(cwd);
+    let config = result?.config;
+    if (!config) {
+        const configPath = join(homedir(), ".config", "opencode", "graphiti.jsonc");
+        try {
+            const raw = readFileSync(configPath, "utf-8");
+            config = parseJsonc(raw);
+        }
+        catch {
+            config = null;
+        }
+    }
+    return { ...DEFAULT_CONFIG, ...(config ?? {}) };
+}

package/esm/src/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const makeGroupId: (prefix: string, directory?: string) => string;
+export declare const graphiti: Plugin;
+//# sourceMappingURL=index.d.ts.map

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

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