@miniaxolotl/grove-opencode-plugin 0.2.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 grove contributors
+
+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/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@miniaxolotl/grove-opencode-plugin",
+  "version": "0.2.6",
+  "type": "module",
+  "description": "OpenCode plugin for Grove - captures memories, injects hot context, manages importance tiers",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/miniaxolotl/grove.git"
+  },
+  "keywords": [
+    "opencode",
+    "grove",
+    "memory",
+    "context",
+    "plugin"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "~1.14.20",
+    "@opencode-ai/sdk": "~1.14.20",
+    "effect": "~3.21.2",
+    "zod": "~4.1.8",
+    "@lib/shared": "0.0.0"
+  },
+  "devDependencies": {
+    "@tsconfig/node22": "~22.0.2",
+    "@types/node": "~22.13.9",
+    "typescript": "~5.8.2"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  }
+}

package/src/capture/hooks.ts

@@ -0,0 +1,70 @@
+import type { GrovePluginOptions } from "../index.js";
+import { MCPClient } from "../client/index.js";
+
+export type CaptureType = "decision" | "error_resolution" | "activity_log" | "reference";
+
+export interface CaptureInput {
+  type: CaptureType;
+  text: string;
+  tags?: string[];
+  sessionId: string;
+  project?: string;
+  importance?: number;
+}
+
+const BASE_IMPORTANCE: Record<CaptureType, number> = {
+  decision: 0.8,
+  error_resolution: 0.75,
+  activity_log: 0.5,
+  reference: 0.4,
+};
+
+function computeImportance(type: CaptureType): number {
+  return BASE_IMPORTANCE[type];
+}
+
+export function createCaptureHooks(
+  directory: string,
+  opts: GrovePluginOptions,
+) {
+  const mcp = new MCPClient({ url: opts.mcpUrl ?? "http://localhost:3100/mcp" });
+
+  async function captureMemory(input: CaptureInput): Promise<void> {
+    const importance = input.importance ?? computeImportance(input.type);
+
+    try {
+      await mcp.saveMemory(input.text, {
+        source: "opencode",
+        project: input.project,
+        tags: input.tags ?? [],
+        sessionId: input.sessionId,
+        importance,
+      });
+    } catch (err) {
+      console.error("[grove] Failed to save memory:", err);
+    }
+  }
+
+  async function onToolExecuted(
+    input: { tool: string; sessionID: string; args: unknown },
+    output: { title: string; output: string },
+  ): Promise<void> {
+    if (input.tool === "memory_save" || input.tool === "memory_note") {
+      return;
+    }
+
+    if (output.title.toLowerCase().includes("error")) {
+      await captureMemory({
+        type: "error_resolution",
+        text: `Tool ${input.tool} error: ${output.output}. User may have resolved it.`,
+        sessionId: input.sessionID,
+        project: opts.project,
+      });
+    }
+  }
+
+  return {
+    capture: captureMemory,
+    onToolExecuted,
+  };
+}

package/src/client/index.ts

@@ -0,0 +1,155 @@
+import type { MemoryMetadata } from "@lib/shared";
+
+export interface MCPToolResult {
+  content: Array<{ type: string; text: string }>;
+}
+
+export interface MemorySearchResult {
+  id: string;
+  text: string;
+  metadata?: MemoryMetadata;
+  score: number;
+}
+
+export interface MCPClientOptions {
+  url: string;
+}
+
+interface JSONRPCResponse {
+  jsonrpc: "2.0";
+  id: string;
+  result?: MCPToolResult;
+  error?: { code: number; message: string };
+}
+
+export class MCPClient {
+  private url: string;
+
+  constructor(options: MCPClientOptions) {
+    this.url = options.url;
+  }
+
+  async callTool(
+    toolName: string,
+    args: Record<string, unknown>,
+  ): Promise<MCPToolResult> {
+    const response = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "tools/call",
+        params: {
+          name: toolName,
+          arguments: args,
+        },
+        id: crypto.randomUUID(),
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`MCP call failed: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json() as JSONRPCResponse;
+
+    if (data.error) {
+      throw new Error(`MCP error: ${data.error.message}`);
+    }
+
+    if (!data.result) {
+      throw new Error("MCP returned no result");
+    }
+
+    return data.result;
+  }
+
+  async saveMemory(
+    information: string,
+    metadata?: {
+      source?: string;
+      project?: string;
+      tags?: string[];
+      sessionId?: string;
+      importance?: number;
+    },
+  ): Promise<string> {
+    const result = await this.callTool("memory_save", {
+      information,
+      metadata,
+    });
+
+    const text = result.content[0]?.text ?? "";
+    const match = text.match(/Saved memory: (.+)/);
+    return match ? match[1] : text;
+  }
+
+  async searchMemories(options: {
+    query: string;
+    project?: string;
+    tags?: string[];
+    limit?: number;
+  }): Promise<MemorySearchResult[]> {
+    const result = await this.callTool("memory_search", {
+      query: options.query,
+      project: options.project,
+      tags: options.tags,
+      limit: options.limit ?? 10,
+    });
+
+    try {
+      return JSON.parse(result.content[0]?.text ?? "[]");
+    } catch {
+      return [];
+    }
+  }
+
+  async compactMemories(options: {
+    project?: string;
+    sessionId?: string;
+    importanceThreshold?: number;
+  }): Promise<number> {
+    const result = await this.callTool("memory_compact", {
+      project: options.project,
+      sessionId: options.sessionId,
+      importanceThreshold: options.importanceThreshold ?? 0.6,
+    });
+
+    const text = result.content[0]?.text ?? "";
+    const match = text.match(/Compacted (\d+)/);
+    return match ? parseInt(match[1], 10) : 0;
+  }
+
+  async pruneMemories(options: {
+    threshold: number;
+    project?: string;
+  }): Promise<number> {
+    const result = await this.callTool("memory_prune", {
+      threshold: options.threshold,
+      project: options.project,
+    });
+
+    const text = result.content[0]?.text ?? "";
+    const match = text.match(/Pruned (\d+)/);
+    return match ? parseInt(match[1], 10) : 0;
+  }
+
+  async updateMemory(
+    id: string,
+    updates: {
+      text?: string;
+      metadata?: {
+        source?: string;
+        project?: string;
+        tags?: string[];
+        importance?: number;
+        sessionId?: string;
+      };
+    },
+  ): Promise<unknown> {
+    return this.callTool("memory_update", { id, ...updates });
+  }
+}

package/src/engine/context.ts

@@ -0,0 +1,48 @@
+import type { GrovePluginOptions } from "../index.js";
+import { MCPClient } from "../client/index.js";
+
+const HOT_THRESHOLD = 0.8;
+
+export function createContextEngine(
+  _directory: string,
+  opts: GrovePluginOptions,
+) {
+  const mcp = new MCPClient({ url: opts.mcpUrl ?? "http://localhost:3100/mcp" });
+
+  async function queryHotMemories(): Promise<MemorySearchResult[]> {
+    try {
+      const memories = await mcp.searchMemories({
+        query: "important decision error resolution",
+        limit: 10,
+      });
+
+      return memories.filter((m) => m.score >= HOT_THRESHOLD);
+    } catch (err) {
+      console.error("[grove] Failed to query hot memories:", err);
+      return [];
+    }
+  }
+
+  async function onSessionCompacting(
+    input: { sessionID: string },
+    output: { context: string[] },
+  ): Promise<void> {
+    console.log(
+      `[grove] Session ${input.sessionID} compacting, context items: ${output.context?.length ?? "unknown"}`,
+    );
+
+    try {
+      const compacted = await mcp.compactMemories({
+        sessionId: input.sessionID,
+        importanceThreshold: opts.importanceThreshold ?? 0.6,
+      });
+      console.log(`[grove] Compacted ${compacted} memories for session ${input.sessionID}`);
+    } catch (err) {
+      console.error("[grove] Failed to compact memories:", err);
+    }
+  }
+
+  return {
+    onSessionCompacting,
+  };
+}

package/src/engine/importance.ts

@@ -0,0 +1,61 @@
+import type { GrovePluginOptions } from "../index.js";
+import { MCPClient } from "../client/index.js";
+
+const DECAY_RATE = 0.01;
+
+export function createImportanceEngine(opts: GrovePluginOptions) {
+  const mcp = new MCPClient({ url: opts.mcpUrl ?? "http://localhost:3100/mcp" });
+
+  function applyDecay(currentImportance: number, daysSinceAccess: number): number {
+    const decayed = currentImportance - daysSinceAccess * DECAY_RATE;
+    return Math.max(0.1, decayed);
+  }
+
+  async function decayMemories(sessionId?: string): Promise<{ decayed: number }> {
+    let decayed = 0;
+
+    try {
+      const memories = await mcp.searchMemories({
+        query: "",
+        limit: 100,
+        project: opts.project,
+      });
+
+      const now = new Date();
+
+      for (const memory of memories) {
+        if (memory.metadata?.importance === undefined || memory.metadata?.importance <= 0.1) {
+          continue;
+        }
+
+        const lastAccessed = memory.metadata.lastAccessedAt
+          ? new Date(memory.metadata.lastAccessedAt)
+          : new Date(memory.metadata.createdAt || now);
+
+        const daysSinceAccess = Math.floor((now.getTime() - lastAccessed.getTime()) / (1000 * 60 * 60 * 24));
+
+        if (daysSinceAccess > 0) {
+          const newImportance = applyDecay(memory.metadata.importance, daysSinceAccess);
+
+          try {
+            await mcp.updateMemory(memory.id, {
+              metadata: { importance: newImportance },
+            });
+            decayed++;
+          } catch {
+            // Memory may have been deleted already
+          }
+        }
+      }
+    } catch (err) {
+      console.error("[grove-plugin] Failed to decay importance:", err);
+    }
+
+    return { decayed };
+  }
+
+  return {
+    applyDecay,
+    decayMemories,
+  };
+}

package/src/engine/staleness.ts

@@ -0,0 +1,60 @@
+import type { GrovePluginOptions } from "../index.js";
+import { MCPClient } from "../client/index.js";
+
+interface StaleMemory {
+  id: string;
+  text: string;
+  metadata: {
+    lastAccessedAt?: string;
+    importance?: number;
+    sessionId?: string;
+  };
+}
+
+export function createStalenessEngine(opts: GrovePluginOptions) {
+  const mcp = new MCPClient({ url: opts.mcpUrl ?? "http://localhost:3100/mcp" });
+
+  async function findStaleMemories(daysThreshold: number): Promise<StaleMemory[]> {
+    const staleMemories: StaleMemory[] = [];
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - daysThreshold);
+
+    try {
+      const memories = await mcp.searchMemories({
+        query: "",
+        limit: 100,
+      });
+
+      for (const memory of memories) {
+        const lastAccessedAt = memory.metadata?.lastAccessedAt;
+        if (lastAccessedAt) {
+          const lastAccessed = new Date(lastAccessedAt);
+          if (lastAccessed < cutoffDate) {
+            staleMemories.push(memory as StaleMemory);
+          }
+        }
+      }
+    } catch (err) {
+      console.error("[grove-plugin] Failed to find stale memories:", err);
+    }
+
+    return staleMemories;
+  }
+
+  async function onStalenessCheck(): Promise<{ staleCount: number; message: string }> {
+    const staleMemories = await findStaleMemories(opts.stalenessDays ?? 7);
+
+    if (staleMemories.length === 0) {
+      return { staleCount: 0, message: "No stale memories found" };
+    }
+
+    const message = `Found ${staleMemories.length} stale memories not accessed in ${opts.stalenessDays ?? 7}+ days. Consider running memory_prune to remove them.`;
+
+    return { staleCount: staleMemories.length, message };
+  }
+
+  return {
+    findStaleMemories,
+    onStalenessCheck,
+  };
+}

package/src/index.ts

@@ -0,0 +1,92 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin/tool";
+import { z } from "zod";
+import { createCaptureHooks } from "./capture/hooks.js";
+import { createContextEngine } from "./engine/context.js";
+import { createStalenessEngine } from "./engine/staleness.js";
+import { createImportanceEngine } from "./engine/importance.js";
+import { MCPClient } from "./client/index.js";
+
+export interface GrovePluginOptions {
+  mcpUrl?: string;
+  project?: string;
+  importanceThreshold?: number;
+  stalenessDays?: number;
+}
+
+export const grovePlugin: Plugin = async (ctx) => {
+  const directory = ctx.directory || ".";
+
+  const mcpUrl = process.env.GROVE_MCP_URL || "http://localhost:3100/mcp";
+  const project = process.env.GROVE_PROJECT;
+
+  const opts: GrovePluginOptions = {
+    mcpUrl,
+    project,
+    importanceThreshold: 0.6,
+    stalenessDays: 7,
+  };
+
+  const capture = createCaptureHooks(directory, opts);
+  const contextEngine = createContextEngine(directory, opts);
+  const stalenessEngine = createStalenessEngine(opts);
+  const importanceEngine = createImportanceEngine(opts);
+  const mcp = new MCPClient({ url: mcpUrl });
+
+  return {
+    tool: {
+      grove_save_memory: tool({
+        description: "Save a memory to Grove semantic storage",
+        args: {
+          information: z.string().describe("The memory content to save"),
+          tags: z.array(z.string()).optional().describe("Tags for the memory"),
+        },
+        execute: async (args, context) => {
+          await capture.capture({
+            type: "activity_log",
+            text: args.information,
+            tags: args.tags,
+            sessionId: context.sessionID,
+            project: opts.project,
+          });
+          return `Saved memory for session ${context.sessionID}`;
+        },
+      }),
+      grove_check_staleness: tool({
+        description: "Check for stale memories that haven't been accessed in a while",
+        args: {},
+        execute: async () => {
+          const result = await stalenessEngine.onStalenessCheck();
+          return result.message;
+        },
+      }),
+      grove_compact_session: tool({
+        description: "Compact memories for a specific session",
+        args: {
+          sessionId: z.string().describe("Session ID to compact"),
+        },
+        execute: async (args) => {
+          const compacted = await mcp.compactMemories({
+            sessionId: args.sessionId,
+            importanceThreshold: opts.importanceThreshold,
+          });
+          return `Compacted ${compacted} memories`;
+        },
+      }),
+    },
+    async "tool.execute.after"(input: { tool: string; sessionID: string; args: unknown }, output: { title: string; output: string }) {
+      await capture.onToolExecuted(input, output);
+    },
+    async "experimental.session.compacting"(input: { sessionID: string }, output: { context: string[]; prompt?: string }) {
+      await contextEngine.onSessionCompacting(input, output);
+      await importanceEngine.decayMemories(input.sessionID);
+
+      const staleResult = await stalenessEngine.onStalenessCheck();
+      if (staleResult.staleCount > 0) {
+        output.context.push(`[grove] ${staleResult.message}`);
+      }
+    },
+  };
+};
+
+export default grovePlugin;

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@tsconfig/node22/tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["node"]
+  },
+  "include": ["src/**/*"]
+}