opencode-graphiti 0.1.12 → 0.2.0-canary.12dc720.20260319065709

package/README.md

@@ -1,55 +1,105 @@
 # opencode-graphiti
 
-OpenCode plugin that provides persistent memory via a
-[Graphiti](https://github.com/getzep/graphiti) knowledge graph.
+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.
-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.
+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 connects to a Graphiti MCP server and:
-
-- Searches Graphiti for relevant facts and entities on each user message
-- Injects memories into the last user message as a `<memory>` block via
-  `experimental.chat.messages.transform`, keeping the system prompt static for
-  prefix caching
-- Detects context drift using Jaccard similarity and re-injects when the
-  conversation topic shifts
-- Buffers user and assistant messages, flushing them to Graphiti on idle or
-  before compaction
-- Preserves key facts during context compaction
-- Saves compaction summaries as episodes so knowledge survives across boundaries
-- Annotates stale facts and filters expired ones automatically
-- Scopes memories per project (and per user) using directory-based group IDs
+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
 
-A running
+Start the
 [Graphiti MCP server](https://github.com/getzep/graphiti/tree/main/mcp_server)
-accessible over HTTP. The easiest way to set one up:
+with its default [FalkorDB](https://www.falkordb.com/) backend:
 
 ```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.
+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 absent until Graphiti comes online.
 
 ## Installation
 
@@ -65,19 +115,14 @@ Add the plugin to your `opencode.json` (or `opencode.jsonc`):
 
 ### 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`:
+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/index.js"]
+  "plugin": ["file:///absolute/path/to/opencode-graphiti/dist/esm/mod.js"]
 }
 ```
 
@@ -87,11 +132,11 @@ 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
+cp dist/esm/mod.js ~/.config/opencode/plugins/opencode-graphiti.js
 
 # Or project-level
 mkdir -p .opencode/plugins
-cp dist/index.js .opencode/plugins/opencode-graphiti.js
+cp dist/esm/mod.js .opencode/plugins/opencode-graphiti.js
 ```
 
 No config entry needed — OpenCode loads plugins from these directories
@@ -101,95 +146,185 @@ automatically.
 
 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`)
+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`
 
-Example `.graphitirc`:
+### Nested Config Shape (recommended)
 
 ```jsonc
 {
-  // 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 memory is re-injected
-  // Lower values mean the topic must drift further before re-injection
-  "driftThreshold": 0.5,
-
-  // Number of days after which facts are annotated as stale
-  "factStaleDays": 30
+  "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.
+values. Canonical nested values take precedence when both forms are supplied.
+
+### Retained Compatibility
+
+The canonical hot-tier config shape is `redis.*`. Only the original Graphiti
+top-level aliases remain supported for backward compatibility. Precedence is:
+
+1. `redis.*` (canonical)
+2. 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` |
+
+Removed top-level Redis aliases are no longer supported.
 
 ## How It Works
 
-### Memory Search and Caching (`chat.message`)
+### 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="graphiti" 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 searches Graphiti for facts and entities
-relevant to the message content. Results are split into project and user scopes
-(70% / 30% budget), deduplicated, filtered for validity, annotated with
-staleness if older than `factStaleDays`, and formatted as Markdown. The
-formatted context is cached on the session state for the messages transform hook
-to pick up.
+On each user message the plugin assembles the current session memory from three
+sources:
 
-On the very first message of a session, the plugin also loads the most recent
-session snapshot episode to prime the conversation with prior context.
+- Recent structured session events
+- The continuously rebuilt priority-tiered snapshot
+- Cached long-term facts from Graphiti
 
-The injection budget is calculated dynamically: 5% of the model's context limit
-(resolved from the provider list) multiplied by 4 characters per token.
+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`)
 
-A separate hook reads the cached memory context and prepends it to the last user
-message as a `<memory data-uuids="...">` block. The `data-uuids` attribute lists
-the fact UUIDs included in the injection, which are tracked in
-`visibleFactUuids` so subsequent searches can filter out already-visible facts.
-This approach keeps the system prompt static, enabling provider-side prefix
-caching, and avoids influencing session titles. The cache is cleared after
-injection so stale context is not re-injected on subsequent LLM calls within the
-same turn.
+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-Based Re-injection (`chat.message`)
+### Drift Detection and Background Cache Refresh
 
-After the first injection, the plugin monitors for context drift on every user
-message. It searches Graphiti for the current message and compares the returned
-fact UUIDs against the previously injected set using Jaccard similarity. When
-similarity drops below `driftThreshold` (default 0.5), the memory cache is
-refreshed with project-scoped results only (no user scope).
+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.
 
-### Message Buffering (`event`)
+### Event Extraction and Buffering (`event`)
 
-User and assistant messages are buffered in memory as they arrive. The plugin
-listens on `message.part.updated` to capture assistant text as it streams, and
-on `message.updated` to finalize completed assistant replies. Buffered messages
-are flushed to Graphiti as episodes:
+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.
 
-- **On idle** (`session.idle`): when the session becomes idle with at least 50
-  bytes of buffered content.
-- **Before compaction** (`session.compacted`): all buffered messages are flushed
-  immediately (no minimum size) so nothing is lost.
+Events are also queued for background ingestion into long-term memory:
 
-If the last buffered message is from the user (i.e. no assistant reply was
-captured), the plugin fetches the latest assistant message from the session API
-as a fallback before flushing.
+- **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 (`session.compacted` + `experimental.session.compacting`)
+### Compaction Preservation
 
 Compaction is handled entirely by OpenCode's native compaction mechanism. The
-plugin participates in two ways:
+plugin ensures session continuity survives each compaction cycle:
 
 1. **Before compaction** (`experimental.session.compacting`): The plugin injects
-   known facts and entities into the compaction context using the same 70% / 30%
-   project/user budget split, so the summarizer preserves important knowledge.
-2. **After compaction** (`session.compacted`): The compaction summary is saved
-   as an episode to Graphiti, ensuring knowledge survives across compaction
-   boundaries.
+   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
 
@@ -201,13 +336,18 @@ projects stay isolated.
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and release
-process.
+process. In CI, pushes to `main` publish `latest` releases, while pull requests
+targeting `main` publish canary builds under the `canary` dist-tag.
 
 ## License
 
 MIT
 
-## Acknowledgement
+## 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).
 
-This project is inspired by
-[opencode-openmemory](https://github.com/happycastle114/opencode-openmemory)
+The original plugin concept is inspired by
+[opencode-openmemory](https://github.com/happycastle114/opencode-openmemory).

package/esm/_dnt.polyfills.d.ts

@@ -47,6 +47,23 @@ declare global {
     }
 }
 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,

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

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

package/esm/_dnt.polyfills.js

@@ -34,6 +34,20 @@ if (!Uint8Array.prototype.findLast) {
         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,

package/esm/deno.d.ts

@@ -5,12 +5,9 @@ declare namespace _default {
     export let license: string;
     export namespace tasks {
         let build: string;
-        namespace deploy {
-            let command: string;
-            let dependencies: string[];
-        }
-        let dev: string;
         let check: string;
+        let deploy: string;
+        let dev: string;
         let lint: string;
         let fmt: string;
     }
@@ -37,6 +34,7 @@ declare namespace _default {
         "@opencode-ai/plugin": string;
         "@opencode-ai/sdk": string;
         cosmiconfig: string;
+        ioredis: string;
         zod: string;
     };
     export let exports: {

package/esm/deno.js

@@ -5,12 +5,9 @@ export default {
     "license": "MIT",
     "tasks": {
         "build": "deno run -A dnt.ts",
-        "deploy": {
-            "command": "cd dist/ && npm publish",
-            "dependencies": ["build"]
-        },
-        "dev": "deno run --allow-all src/index.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"
     },
@@ -30,9 +27,10 @@ export default {
     "nodeModulesDir": "auto",
     "imports": {
         "@modelcontextprotocol/sdk": "npm:@modelcontextprotocol/sdk@^1.25.2",
-        "@opencode-ai/plugin": "npm:@opencode-ai/plugin@^1.1.53",
-        "@opencode-ai/sdk": "npm:@opencode-ai/sdk@^1.1.53",
+        "@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": {

package/esm/mod.d.ts

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

package/esm/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAC7B,cAAc,gBAAgB,CAAC"}
+{"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

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

package/esm/src/config.d.ts

@@ -2,6 +2,14 @@ import type { GraphitiConfig } from "./types/index.js";
 type ConfigLoadResult = {
     config: unknown;
 } | null;
+type ConfigLoadErrorCode = "config-discovery-init" | "config-discovery-search" | "config-file-load" | "config-invalid";
+export declare class ConfigLoadError extends Error {
+    readonly code: ConfigLoadErrorCode;
+    constructor(message: string, options: {
+        cause?: unknown;
+        code: ConfigLoadErrorCode;
+    });
+}
 export interface ConfigExplorerAdapter {
     search(from?: string): ConfigLoadResult;
     load(filePath: string): ConfigLoadResult;
@@ -9,11 +17,6 @@ export interface ConfigExplorerAdapter {
 type ConfigExplorerFactory = () => ConfigExplorerAdapter;
 export declare const setConfigExplorerAdapterForTesting: (factory: ConfigExplorerFactory) => void;
 export declare const resetConfigExplorerAdapterForTesting: () => void;
-/**
- * Load Graphiti configuration via cosmiconfig discovery, with a legacy fallback
- * to `~/.config/opencode/.graphitirc` only when discovery succeeds and returns
- * no result.
- */
 export declare function loadConfig(directory?: string): GraphitiConfig;
 export {};
 //# sourceMappingURL=config.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/src/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAWvD,KAAK,gBAAgB,GAAG;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAAC;AAMnD,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;AAgDzD,eAAO,MAAM,kCAAkC,GAC7C,SAAS,qBAAqB,KAC7B,IAEF,CAAC;AAEF,eAAO,MAAM,oCAAoC,QAAO,IAEvD,CAAC;AAiEF;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,cAAc,CAa7D"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/src/config.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAqB,MAAM,kBAAkB,CAAC;AAkB1E,KAAK,gBAAgB,GAAG;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAAC;AAEnD,KAAK,mBAAmB,GACpB,uBAAuB,GACvB,yBAAyB,GACzB,kBAAkB,GAClB,gBAAgB,CAAC;AAErB,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;gBAGjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,mBAAmB,CAAA;KAAE;CAc1D;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;AA8KzD,eAAO,MAAM,kCAAkC,GAC7C,SAAS,qBAAqB,KAC7B,IAEF,CAAC;AAEF,eAAO,MAAM,oCAAoC,QAAO,IAEvD,CAAC;AA0EF,wBAAgB,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,cAAc,CAiB7D"}