@qdang46/opencode-dcp-plugin 0.2.0

package/README.md

@@ -0,0 +1,54 @@
+# @qdang46/opencode-dcp-plugin
+
+NAPI-RS native Dynamic Context Pruning plugin for [OpenCode](https://github.com/anomalyco/opencode).
+
+Automatically reduces token usage in OpenCode sessions by pruning obsolete tool outputs, 
+deduplicating repeated calls, purging errored tool inputs, and compressing stale conversation 
+content — all powered by a Rust native addon for zero-serialization performance.
+
+## Installation
+
+```bash
+opencode plugin add @qdang46/opencode-dcp-plugin
+```
+
+Or globally:
+
+```bash
+opencode plugin @qdang46/opencode-dcp-plugin@latest --global
+```
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **Message transform** | Automatically prunes, deduplicates, and compresses messages before each LLM request |
+| **System prompt injection** | Appends DCP instructions so the model can use the compress tool |
+| **Compress tool** | LLM-driven compression of stale conversation ranges into technical summaries |
+| **Decompress / Recompress** | Restore or re-activate compressed blocks on demand |
+| **Slash commands** | `/dcp context`, `/dcp stats`, `/dcp sweep`, `/dcp manual`, `/dcp decompress`, `/dcp recompress` |
+| **Config cascade** | JSONC config loaded from 4-tier cascade (builtin → global → custom → project) |
+| **Cache stability** | `agent-message`, `aggressive`, or `manual` modes for prompt cache preservation |
+| **Protected tools** | Glob patterns to keep specific tool outputs from being pruned |
+
+## Configuration
+
+DCP loads configuration from `.dynamic_context_pruning/config.jsonc` in your project directory.
+See the [dcp.schema.json](./dcp.schema.json) for the full config schema.
+
+## Development
+
+```bash
+# Build the Rust native addon
+cargo build --release -p opencode-dcp-bridge
+
+# Compile TypeScript
+cd opencode-dcp-plugin && npx tsc
+
+# Test
+node -e "require('./opencode-dcp-bridge.darwin-arm64.node')"
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const _default: {
+    server: Plugin;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,186 @@
+import { createTools } from "./tools.js";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, resolve, join } from "path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const _require = createRequire(import.meta.url);
+function loadBridge() {
+    const root = resolve(__dirname, "..");
+    const candidates = [
+        join(root, "opencode-dcp-bridge.darwin-arm64.node"),
+        join(root, "opencode-dcp-bridge.darwin-x64.node"),
+        join(root, "opencode-dcp-bridge.linux-x64-gnu.node"),
+        join(root, "opencode-dcp-bridge.win32-x64-msvc.node"),
+    ];
+    for (const name of candidates) {
+        try {
+            return _require(name);
+        }
+        catch {
+            /* try next */
+        }
+    }
+    throw new Error("Cannot load opencode-dcp-bridge native addon.\n" +
+        "Build: cd ~/Projects/dynamic_context_pruning && cargo build -p opencode-dcp-bridge");
+}
+function formatHelpText() {
+    return [
+        "╭──────────────────────────────────────────────────────────────╮",
+        "│                      DCP Commands                           │",
+        "╰──────────────────────────────────────────────────────────────╯",
+        "",
+        "  /dcp                    Show this help message",
+        "  /dcp context            Show context analysis (turns, blocks, tokens)",
+        "  /dcp stats              Show pruning statistics",
+        "  /dcp sweep              Flush pending prune strategies",
+        "  /dcp manual <on|off>    Toggle manual mode",
+        "  /dcp decompress <id>    Restore a compressed block",
+        "  /dcp recompress <id>    Re-activate a decompressed block",
+        "  /dcp-compress [focus]   Trigger manual compression",
+        "",
+        "  Tools (available to the LLM):",
+        "    compress    Replace stale content with summaries",
+        "    decompress  Restore compressed blocks",
+        "    recompress  Re-activate decompressed blocks",
+        "",
+    ].join("\n");
+}
+const createPlugin = async (_ctx) => {
+    const nativeBridge = loadBridge();
+    const configJson = nativeBridge.loadDcpConfig();
+    const config = JSON.parse(configJson);
+    const pruner = new nativeBridge.DcpPruner(configJson);
+    return {
+        // ─── Message pipeline ─────────────────────────────────────────
+        "experimental.chat.messages.transform": async (_input, output) => {
+            try {
+                if (!output.messages || output.messages.length === 0)
+                    return;
+                const json = JSON.stringify(output.messages);
+                const transformed = pruner.transformMessages(json);
+                const parsed = JSON.parse(transformed);
+                output.messages.length = 0;
+                output.messages.push(...parsed);
+            }
+            catch (err) {
+                console.error("[DCP] transform_messages error:", err);
+            }
+        },
+        // ─── System prompt ────────────────────────────────────────────
+        "experimental.chat.system.transform": async (_input, output) => {
+            try {
+                const joined = output.system.join("\n");
+                const result = pruner.transformSystem(joined);
+                if (result !== joined) {
+                    output.system[output.system.length - 1] = result;
+                }
+            }
+            catch (err) {
+                console.error("[DCP] transform_system error:", err);
+            }
+        },
+        // ─── Slash commands ──────────────────────────────────────────
+        "command.execute.before": async (input, output) => {
+            try {
+                const parts = input.command.split(/\s+/);
+                let cmd = parts[0];
+                // Strip leading slash if present (OpenCode passes "/dcp")
+                if (cmd.startsWith("/")) {
+                    cmd = cmd.slice(1);
+                }
+                if (cmd === "dcp" || cmd === "dcp-compress") {
+                    const subcommand = parts.length > 1 ? parts[1] : "help";
+                    const args = parts.slice(2);
+                    // Handle help in TypeScript (purely presentational)
+                    if (subcommand === "help") {
+                        output.parts.length = 0;
+                        output.parts.push({
+                            type: "text",
+                            text: formatHelpText(),
+                            id: `dcp-${Date.now()}`,
+                            sessionID: input.sessionID,
+                            messageID: `cmd-${Date.now()}`,
+                            synthetic: true,
+                        });
+                        return;
+                    }
+                    const actualCmd = cmd === "dcp-compress" ? "compress" : subcommand;
+                    const resultJson = pruner.handleCommand(actualCmd, JSON.stringify(args), "[]");
+                    const result = JSON.parse(resultJson);
+                    output.parts.length = 0;
+                    output.parts.push({
+                        type: "text",
+                        text: result.status === "ok"
+                            ? result.text
+                            : `⚠️ ${result.text}`,
+                        id: `dcp-${Date.now()}`,
+                        sessionID: input.sessionID,
+                        messageID: `cmd-${Date.now()}`,
+                        synthetic: true,
+                    });
+                }
+            }
+            catch (err) {
+                console.error("[DCP] command.execute.before error:", err);
+            }
+        },
+        // ─── Event tracking ──────────────────────────────────────────
+        event: async (input) => {
+            try {
+                if (input.event?.type) {
+                    pruner.notifyEvent(JSON.stringify(input.event));
+                }
+            }
+            catch (err) {
+                console.error("[DCP] event error:", err);
+            }
+        },
+        // ─── Config hook: register slash commands + negotiate permissions ─
+        config: async (opencodeConfig) => {
+            try {
+                if (config.compress?.permission !== "deny") {
+                    opencodeConfig.command ??= {};
+                    // Register /dcp as a slash command (shows in palette)
+                    opencodeConfig.command["dcp"] = {
+                        template: "",
+                        description: "DCP: context, stats, sweep, manual, decompress, recompress",
+                    };
+                    // Register /dcp-compress as a slash command
+                    opencodeConfig.command["dcp-compress"] = {
+                        template: "",
+                        description: "Trigger DCP manual compression with: /dcp-compress [focus]",
+                    };
+                    // Add compress as a primary tool so it's always available
+                    const existingPrimaryTools = opencodeConfig.experimental?.primary_tools ?? [];
+                    opencodeConfig.experimental = {
+                        ...opencodeConfig.experimental,
+                        primary_tools: [...existingPrimaryTools, "compress"],
+                    };
+                    // Set compress tool permission to match config
+                    const permission = opencodeConfig.permission ?? {};
+                    opencodeConfig.permission = {
+                        ...permission,
+                        compress: config.compress?.permission ?? "allow",
+                    };
+                }
+            }
+            catch (err) {
+                console.error("[DCP] config error:", err);
+            }
+        },
+        // ─── Cleanup on plugin reload ────────────────────────────────
+        dispose: async () => {
+            try {
+                pruner.setSessionId("__dispose__");
+                pruner.notifyEvent(JSON.stringify({ type: "plugin.dispose" }));
+            }
+            catch (err) {
+                console.error("[DCP] dispose error:", err);
+            }
+        },
+        // ─── Tools exposed to the LLM ────────────────────────────────
+        tool: createTools(pruner),
+    };
+};
+export default { server: createPlugin };

package/dist/tools.d.ts

@@ -0,0 +1,15 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+interface DcpPruner {
+    transformMessages(messagesJson: string): string;
+    transformSystem(system: string): string;
+    handleCompress(argsJson: string, messagesJson: string): string;
+    decompress(blockId: number): string;
+    recompress(blockId: number): string;
+    handleCommand(cmd: string, argsJson: string, messagesJson: string): string;
+    notifyEvent(eventJson: string): void;
+    hasPendingWork(): boolean;
+    stats(): string;
+    setSessionId(sessionId: string): void;
+}
+export declare function createTools(pruner: DcpPruner): Record<string, ToolDefinition>;
+export {};

package/dist/tools.js

@@ -0,0 +1,52 @@
+import { tool } from "@opencode-ai/plugin";
+export function createTools(pruner) {
+    return {
+        compress: tool({
+            description: "Replace stale conversation content with technical summaries. " +
+                "Use for closed/discussed topics to free context space.",
+            args: {
+                topic: tool.schema
+                    .string()
+                    .describe("Short label (3-5 words) for the batch - e.g. 'Auth Exploration'"),
+                content: tool.schema
+                    .array(tool.schema.object({
+                    startId: tool.schema
+                        .string()
+                        .describe("Message or block ID beginning of range (e.g. m0001, b2)"),
+                    endId: tool.schema
+                        .string()
+                        .describe("Message or block ID end of range (e.g. m0012, b5)"),
+                    summary: tool.schema
+                        .string()
+                        .describe("Complete technical summary replacing all content in range"),
+                }))
+                    .describe("One or more ranges to compress"),
+            },
+            async execute(args) {
+                const resultJson = pruner.handleCompress(JSON.stringify(args), "[]");
+                const result = JSON.parse(resultJson);
+                return `Compressed ${result.blocks?.length || result.compressed_count || 0} messages.`;
+            },
+        }),
+        decompress: tool({
+            description: "Restore a compressed block to its original messages.",
+            args: {
+                blockId: tool.schema.number().describe("Block ID to restore (e.g. 1, 2, 3)"),
+            },
+            async execute(args) {
+                pruner.decompress(args.blockId);
+                return `Decompressed block ${args.blockId}.`;
+            },
+        }),
+        recompress: tool({
+            description: "Re-activate a user-decompressed block for future compression.",
+            args: {
+                blockId: tool.schema.number().describe("Block ID to re-compress (e.g. 1, 2, 3)"),
+            },
+            async execute(args) {
+                pruner.recompress(args.blockId);
+                return `Recompressed block ${args.blockId}.`;
+            },
+        }),
+    };
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@qdang46/opencode-dcp-plugin",
+  "version": "0.2.0",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "napi": {
+    "name": "opencode-dcp-bridge",
+    "triples": {
+      "defaults": true
+    }
+  },
+  "scripts": {
+    "build": "cd .. && cargo build -p opencode-dcp-bridge && cp target/debug/libopencode_dcp_bridge.dylib opencode-dcp-plugin/opencode-dcp-bridge.darwin-arm64.node",
+    "build:release": "cd .. && cargo build --release -p opencode-dcp-bridge && cp target/release/libopencode_dcp_bridge.dylib opencode-dcp-plugin/opencode-dcp-bridge.darwin-arm64.node",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist && rm -f *.node",
+    "prepublishOnly": "npm run build:release && npx tsc",
+    "postpublish": "echo \"Published! Install with: opencode plugin add @qdang46/opencode-dcp-plugin\""
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.4.3"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.17.9",
+    "@types/node": "^26.0.0",
+    "typescript": "^5.9.3",
+    "zod": "^3.25.76"
+  },
+  "files": [
+    "dist/",
+    "opencode-dcp-bridge.*.node",
+    "npm/",
+    "README.md"
+  ],
+  "description": "NAPI-RS native OpenCode plugin for Dynamic Context Pruning \u2014 intelligently manages conversation context to optimize token usage",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "plugin",
+    "context",
+    "pruning",
+    "dcp",
+    "tokens"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/quangdang46/dynamic_context_pruning",
+  "bugs": {
+    "url": "https://github.com/quangdang46/dynamic_context_pruning/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/quangdang46/dynamic_context_pruning.git",
+    "directory": "opencode-dcp-plugin"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}