context-goblin 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Volodymyr Melnychuk
+
+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,126 @@
+# Context Goblin
+
+An OpenCode plugin that hoards tiny project-context notes so agents read less and waste fewer tokens.
+
+> Feed your agent crumbs, not the whole repo.
+
+## What it does
+
+Context Goblin creates and maintains a compact project context cache for OpenCode agents.
+
+Instead of repeatedly scanning the whole repository, the agent can start from:
+
+```txt
+.opencode/cache/context-goblin/project-context.md
+```
+
+The cache is designed to summarize:
+
+* detected stack
+* package manager
+* important commands
+* directory structure
+* entry points
+* relevant config files
+* git state
+* safety exclusions
+* agent instructions
+
+## What it does not do
+
+Context Goblin does not directly control model-provider prompt caching.
+
+Provider-side prompt caching is handled by the model provider. This plugin focuses on practical repository-context discipline: read the project cache first, then inspect only the files required for the current task.
+
+## Planned OpenCode usage
+
+After installation, users will be able to add the plugin to `opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["context-goblin"]
+}
+```
+
+## Tools
+
+Context Goblin exposes these OpenCode tools:
+
+```txt
+context_goblin_read
+context_goblin_refresh
+context_goblin_status
+```
+
+## Cache location
+
+```txt
+.opencode/cache/context-goblin/project-context.md
+.opencode/cache/context-goblin/project-context.state.json
+```
+
+## Does it actually save context?
+
+Context Goblin includes a benchmark fixture that compares two OpenCode runs:
+
+```txt
+Baseline:
+  OpenCode analyzes the project without Context Goblin.
+
+Context Goblin:
+  OpenCode starts from `.opencode/cache/context-goblin/project-context.md`.
+```
+
+The benchmark reports:
+
+```txt
+- unique files read
+- tool calls
+- cache size
+- secret leakage check
+- optional token/cost stats when available
+```
+
+The goal is not to fake exact token savings. The goal is to prove that the agent reads fewer files and starts from a compact cache.
+
+Run:
+
+```bash
+npm run benchmark
+```
+
+Output:
+
+```txt
+benchmark-results/context-goblin-benchmark.md
+```
+
+## Safety model
+
+Context Goblin should never cache secrets or generated dependency files.
+
+Default exclusions include:
+
+```txt
+.env
+.env.*
+*.pem
+*.key
+node_modules/**
+.git/**
+dist/**
+build/**
+coverage/**
+.next/**
+.nuxt/**
+.output/**
+```
+
+## Development status
+
+This project is currently in early MVP development.
+
+## License
+
+MIT

package/dist/src/cacheStatus.d.ts

@@ -0,0 +1,2 @@
+import type { CacheStatus } from "./types.js";
+export declare function cacheStatus(rootDir: string): Promise<CacheStatus>;

package/dist/src/cacheStatus.js

@@ -0,0 +1,45 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { CACHE_MARKDOWN, CACHE_STATE } from "./constants.js";
+import { hashProjectState } from "./hashProjectState.js";
+async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function cacheStatus(rootDir) {
+    const cachePath = path.join(rootDir, CACHE_MARKDOWN);
+    const statePath = path.join(rootDir, CACHE_STATE);
+    const projectHash = await hashProjectState(rootDir);
+    const cacheExists = await exists(cachePath);
+    const stateExists = await exists(statePath);
+    if (!cacheExists && !stateExists) {
+        return { exists: false, stale: true, reason: "missing cache", cachePath, statePath, projectHash: projectHash.hash };
+    }
+    if (!cacheExists) {
+        return { exists: false, stale: true, reason: "cache markdown missing", cachePath, statePath, projectHash: projectHash.hash };
+    }
+    if (!stateExists) {
+        return { exists: true, stale: true, reason: "state JSON missing", cachePath, statePath, projectHash: projectHash.hash };
+    }
+    try {
+        const state = JSON.parse(await fs.readFile(statePath, "utf8"));
+        const stale = state.projectHash !== projectHash.hash;
+        return {
+            exists: true,
+            stale,
+            reason: stale ? "project hash changed" : "fresh",
+            cachePath,
+            statePath,
+            projectHash: projectHash.hash,
+            state,
+        };
+    }
+    catch {
+        return { exists: true, stale: true, reason: "state JSON invalid", cachePath, statePath, projectHash: projectHash.hash };
+    }
+}

package/dist/src/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const CACHE_VERSION = "0.1.0";
+export declare const CACHE_DIR = ".opencode/cache/context-goblin";
+export declare const CACHE_MARKDOWN = ".opencode/cache/context-goblin/project-context.md";
+export declare const CACHE_STATE = ".opencode/cache/context-goblin/project-context.state.json";
+export declare const DEFAULT_MAX_CACHE_KB = 25;
+export declare const HASH_RELEVANT_FILES: string[];
+export declare const SAFETY_EXCLUSIONS: string[];

package/dist/src/constants.js

@@ -0,0 +1,39 @@
+export const CACHE_VERSION = "0.1.0";
+export const CACHE_DIR = ".opencode/cache/context-goblin";
+export const CACHE_MARKDOWN = `${CACHE_DIR}/project-context.md`;
+export const CACHE_STATE = `${CACHE_DIR}/project-context.state.json`;
+export const DEFAULT_MAX_CACHE_KB = 25;
+export const HASH_RELEVANT_FILES = [
+    "package.json",
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "yarn.lock",
+    "bun.lockb",
+    "tsconfig.json",
+    "jsconfig.json",
+    "vite.config.ts",
+    "vite.config.js",
+    "next.config.js",
+    "next.config.mjs",
+    "opencode.json",
+    "opencode.jsonc",
+    "AGENTS.md",
+    "README.md",
+];
+export const SAFETY_EXCLUSIONS = [
+    ".env",
+    ".env.*",
+    "*.pem",
+    "*.key",
+    "secrets.json",
+    "credentials.json",
+    "node_modules/**",
+    ".git/**",
+    "dist/**",
+    "build/**",
+    "coverage/**",
+    ".next/**",
+    ".nuxt/**",
+    ".output/**",
+    `${CACHE_DIR}/**`,
+];

package/dist/src/detectStack.d.ts

@@ -0,0 +1,2 @@
+import type { DetectedStack } from "./types.js";
+export declare function detectStack(rootDir: string): Promise<DetectedStack>;

package/dist/src/detectStack.js

@@ -0,0 +1,64 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(filePath) {
+    try {
+        return JSON.parse(await fs.readFile(filePath, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+export async function detectStack(rootDir) {
+    const packageJsonPath = path.join(rootDir, "package.json");
+    const packageJson = await readJson(packageJsonPath);
+    const dependencies = {
+        ...(packageJson.dependencies ?? {}),
+        ...(packageJson.devDependencies ?? {}),
+    };
+    const scripts = packageJson.scripts ?? {};
+    const frameworks = [];
+    const languages = [];
+    const entryPoints = [];
+    const notes = [];
+    let packageManager = "[NEEDS INPUT]";
+    if (await exists(path.join(rootDir, "pnpm-lock.yaml")))
+        packageManager = "pnpm";
+    else if (await exists(path.join(rootDir, "package-lock.json")))
+        packageManager = "npm";
+    else if (await exists(path.join(rootDir, "yarn.lock")))
+        packageManager = "yarn";
+    else if (await exists(path.join(rootDir, "bun.lockb")))
+        packageManager = "bun";
+    if (await exists(path.join(rootDir, "tsconfig.json")))
+        languages.push("TypeScript");
+    if (await exists(path.join(rootDir, "jsconfig.json")) || languages.length === 0)
+        languages.push("JavaScript");
+    if (dependencies.next || (await exists(path.join(rootDir, "next.config.js"))) || (await exists(path.join(rootDir, "next.config.mjs"))))
+        frameworks.push("Next.js");
+    if (dependencies.react)
+        frameworks.push("React");
+    if (dependencies.vite || (await exists(path.join(rootDir, "vite.config.ts"))) || (await exists(path.join(rootDir, "vite.config.js"))))
+        frameworks.push("Vite");
+    if (dependencies.express)
+        frameworks.push("Express");
+    if (Object.keys(packageJson).length > 0 && !frameworks.includes("Node.js"))
+        frameworks.push("Node.js");
+    for (const candidate of ["src/index.ts", "src/index.js", "src/main.tsx", "src/main.ts", "app/page.tsx", "pages/index.tsx"]) {
+        if (await exists(path.join(rootDir, candidate)))
+            entryPoints.push(candidate);
+    }
+    if (await exists(path.join(rootDir, "app")))
+        notes.push("Uses app directory");
+    if (Object.keys(scripts).length === 0)
+        notes.push("scripts: [NEEDS INPUT]");
+    return { packageManager, languages, frameworks, scripts, entryPoints, notes };
+}

package/dist/src/generateProjectContext.d.ts

@@ -0,0 +1,2 @@
+import type { ContextGoblinOptions, ProjectState } from "./types.js";
+export declare function generateProjectContext(options: ContextGoblinOptions): Promise<ProjectState>;

package/dist/src/generateProjectContext.js

@@ -0,0 +1,103 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { CACHE_MARKDOWN, CACHE_STATE, CACHE_VERSION, DEFAULT_MAX_CACHE_KB, SAFETY_EXCLUSIONS } from "./constants.js";
+import { detectStack } from "./detectStack.js";
+import { hashProjectState } from "./hashProjectState.js";
+import { isDeniedPath, redactSecrets } from "./security.js";
+import { truncateMarkdown } from "./truncateMarkdown.js";
+async function listDirectoryMap(rootDir, dir = ".", depth = 0) {
+    if (depth > 2)
+        return [];
+    const absoluteDir = path.join(rootDir, dir);
+    let entries = [];
+    try {
+        const dirents = await fs.readdir(absoluteDir, { withFileTypes: true });
+        for (const dirent of dirents.sort((a, b) => a.name.localeCompare(b.name))) {
+            const relativePath = dir === "." ? dirent.name : `${dir}/${dirent.name}`;
+            if (isDeniedPath(relativePath))
+                continue;
+            entries.push(`${"  ".repeat(depth)}- ${dirent.name}${dirent.isDirectory() ? "/" : ""}`);
+            if (dirent.isDirectory())
+                entries = entries.concat(await listDirectoryMap(rootDir, relativePath, depth + 1));
+            if (entries.length >= 120) {
+                entries.push(`${"  ".repeat(depth)}- ...`);
+                return entries;
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return entries;
+}
+async function readTextIfAllowed(rootDir, relativePath) {
+    if (isDeniedPath(relativePath))
+        return undefined;
+    try {
+        return redactSecrets(await fs.readFile(path.join(rootDir, relativePath), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function formatScripts(scripts) {
+    const entries = Object.entries(scripts);
+    if (entries.length === 0)
+        return "- [NEEDS INPUT] No package scripts detected.";
+    return entries.map(([name, command]) => `- ${name}: \`${command}\``).join("\n");
+}
+export async function generateProjectContext(options) {
+    const rootDir = options.rootDir;
+    const maxCacheKb = options.maxCacheKb ?? DEFAULT_MAX_CACHE_KB;
+    const stack = await detectStack(rootDir);
+    const projectHash = await hashProjectState(rootDir);
+    const directoryMap = await listDirectoryMap(rootDir);
+    const agents = await readTextIfAllowed(rootDir, "AGENTS.md");
+    const markdown = truncateMarkdown(redactSecrets(`# Context Goblin Project Cache
+
+Generated: ${new Date().toISOString()}
+Version: ${CACHE_VERSION}
+
+## Detected Stack
+
+- Package manager: ${stack.packageManager}
+- Languages: ${stack.languages.length ? stack.languages.join(", ") : "[NEEDS INPUT]"}
+- Frameworks: ${stack.frameworks.length ? stack.frameworks.join(", ") : "[NEEDS INPUT]"}
+- Entry points: ${stack.entryPoints.length ? stack.entryPoints.join(", ") : "[NEEDS INPUT]"}
+- Notes: ${stack.notes.length ? stack.notes.join("; ") : "none"}
+
+## Important Commands
+
+${formatScripts(stack.scripts)}
+
+## Directory Map
+
+${directoryMap.length ? directoryMap.join("\n") : "- [NEEDS INPUT] No readable project files detected."}
+
+## Safety Exclusions
+
+${SAFETY_EXCLUSIONS.map((item) => `- ${item}`).join("\n")}
+
+Denied paths are summarized only. Their contents are not read into this cache.
+
+## Agent Instructions
+
+Before scanning broad repository files:
+
+1. Read this cache.
+2. Inspect only the smallest file set needed for the task.
+3. Never read denied paths or secret-looking files.
+
+${agents ? `### Existing AGENTS.md\n\n${agents}` : "No AGENTS.md found."}
+`), maxCacheKb);
+    await fs.mkdir(path.join(rootDir, path.dirname(CACHE_MARKDOWN)), { recursive: true });
+    await fs.writeFile(path.join(rootDir, CACHE_MARKDOWN), markdown);
+    const state = {
+        version: CACHE_VERSION,
+        generatedAt: new Date().toISOString(),
+        projectHash: projectHash.hash,
+        trackedFiles: projectHash.trackedFiles,
+    };
+    await fs.writeFile(path.join(rootDir, CACHE_STATE), `${JSON.stringify(state, null, 2)}\n`);
+    return state;
+}

package/dist/src/hashProjectState.d.ts

@@ -0,0 +1,2 @@
+import type { HashResult } from "./types.js";
+export declare function hashProjectState(rootDir: string): Promise<HashResult>;

package/dist/src/hashProjectState.js

@@ -0,0 +1,42 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { HASH_RELEVANT_FILES } from "./constants.js";
+const execFileAsync = promisify(execFile);
+async function readIfExists(rootDir, relativePath) {
+    try {
+        return await fs.readFile(path.join(rootDir, relativePath), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+async function gitState(rootDir) {
+    try {
+        const branch = await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: rootDir });
+        const head = await execFileAsync("git", ["rev-parse", "HEAD"], { cwd: rootDir });
+        return `branch:${branch.stdout.trim()}\nhead:${head.stdout.trim()}`;
+    }
+    catch {
+        return "git:[unavailable]";
+    }
+}
+export async function hashProjectState(rootDir) {
+    const hash = crypto.createHash("sha256");
+    const trackedFiles = [];
+    for (const relativePath of HASH_RELEVANT_FILES) {
+        const content = await readIfExists(rootDir, relativePath);
+        if (content === undefined)
+            continue;
+        trackedFiles.push(relativePath);
+        hash.update(`file:${relativePath}\n`);
+        hash.update(content);
+        hash.update("\n");
+    }
+    const git = await gitState(rootDir);
+    trackedFiles.push("[git-state]");
+    hash.update(git);
+    return { hash: hash.digest("hex"), trackedFiles };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,9 @@
+import { type Plugin } from "@opencode-ai/plugin";
+export { cacheStatus } from "./cacheStatus.js";
+export { detectStack } from "./detectStack.js";
+export { generateProjectContext } from "./generateProjectContext.js";
+export { hashProjectState } from "./hashProjectState.js";
+export { isDeniedPath, redactSecrets } from "./security.js";
+export { truncateMarkdown } from "./truncateMarkdown.js";
+export declare const ContextGoblin: Plugin;
+export default ContextGoblin;

package/dist/src/index.js

@@ -0,0 +1,42 @@
+import fs from "node:fs/promises";
+import { tool } from "@opencode-ai/plugin";
+import { cacheStatus } from "./cacheStatus.js";
+import { CACHE_MARKDOWN } from "./constants.js";
+import { generateProjectContext } from "./generateProjectContext.js";
+export { cacheStatus } from "./cacheStatus.js";
+export { detectStack } from "./detectStack.js";
+export { generateProjectContext } from "./generateProjectContext.js";
+export { hashProjectState } from "./hashProjectState.js";
+export { isDeniedPath, redactSecrets } from "./security.js";
+export { truncateMarkdown } from "./truncateMarkdown.js";
+export const ContextGoblin = async () => {
+    return {
+        tool: {
+            context_goblin_status: tool({
+                description: "Check whether the Context Goblin project cache exists and is fresh.",
+                args: {},
+                async execute(_args, context) {
+                    return JSON.stringify(await cacheStatus(context.worktree), null, 2);
+                },
+            }),
+            context_goblin_refresh: tool({
+                description: "Regenerate the Context Goblin project cache safely.",
+                args: {
+                    maxCacheKb: tool.schema.number().optional(),
+                },
+                async execute(args, context) {
+                    const state = await generateProjectContext({ rootDir: context.worktree, maxCacheKb: args.maxCacheKb });
+                    return JSON.stringify({ ok: true, state }, null, 2);
+                },
+            }),
+            context_goblin_read: tool({
+                description: "Read the compact Context Goblin project cache.",
+                args: {},
+                async execute(_args, context) {
+                    return await fs.readFile(`${context.worktree}/${CACHE_MARKDOWN}`, "utf8");
+                },
+            }),
+        },
+    };
+};
+export default ContextGoblin;

package/dist/src/security.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeRelativePath(filePath: string): string;
+export declare function isDeniedPath(filePath: string): boolean;
+export declare function redactSecrets(input: string): string;

package/dist/src/security.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+import { CACHE_DIR } from "./constants.js";
+const deniedExact = new Set([".env", "private.key", "secrets.json", "credentials.json"]);
+const deniedDirs = new Set([
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    ".git",
+    ".next",
+    ".nuxt",
+    ".output",
+]);
+export function normalizeRelativePath(filePath) {
+    return filePath.split(path.sep).join("/").replace(/^\.\//, "");
+}
+export function isDeniedPath(filePath) {
+    const normalized = normalizeRelativePath(filePath);
+    const basename = path.posix.basename(normalized);
+    const segments = normalized.split("/");
+    if (deniedExact.has(normalized) || deniedExact.has(basename))
+        return true;
+    if (basename.startsWith(".env"))
+        return true;
+    if (basename.endsWith(".key") || basename.endsWith(".pem"))
+        return true;
+    if (segments.some((segment) => deniedDirs.has(segment)))
+        return true;
+    if (normalized === CACHE_DIR || normalized.startsWith(`${CACHE_DIR}/`))
+        return true;
+    return false;
+}
+export function redactSecrets(input) {
+    return input.replace(/^([\w.-]*(?:API_KEY|TOKEN|SECRET|PASSWORD|PRIVATE_KEY)[\w.-]*\s*=\s*)(.+)$/gim, "$1[REDACTED]");
+}

package/dist/src/truncateMarkdown.d.ts

@@ -0,0 +1,2 @@
+export declare function byteSize(input: string): number;
+export declare function truncateMarkdown(markdown: string, maxCacheKb: number): string;

package/dist/src/truncateMarkdown.js

@@ -0,0 +1,40 @@
+import { Buffer } from "node:buffer";
+export function byteSize(input) {
+    return Buffer.byteLength(input, "utf8");
+}
+export function truncateMarkdown(markdown, maxCacheKb) {
+    const maxBytes = maxCacheKb * 1024;
+    if (byteSize(markdown) <= maxBytes)
+        return markdown;
+    const lines = markdown.split("\n");
+    const criticalHeadings = new Set([
+        "# Context Goblin Project Cache",
+        "## Detected Stack",
+        "## Important Commands",
+        "## Directory Map",
+        "## Safety Exclusions",
+        "## Agent Instructions",
+    ]);
+    const kept = [];
+    let currentHeading = "";
+    let sectionLineCount = 0;
+    for (const line of lines) {
+        if (line.startsWith("#")) {
+            currentHeading = line;
+            sectionLineCount = 0;
+        }
+        sectionLineCount += 1;
+        if (criticalHeadings.has(currentHeading) || sectionLineCount <= 20)
+            kept.push(line);
+    }
+    let output = `${kept.join("\n")}\n\n[TRUNCATED]\n`;
+    while (byteSize(output) > maxBytes && kept.length > 8) {
+        kept.splice(Math.max(1, kept.length - 4), 1);
+        output = `${kept.join("\n")}\n\n[TRUNCATED]\n`;
+    }
+    if (byteSize(output) > maxBytes) {
+        const marker = "\n\n[TRUNCATED]\n";
+        output = output.slice(0, Math.max(0, maxBytes - byteSize(marker) - 4)) + marker;
+    }
+    return output;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,31 @@
+export interface ContextGoblinOptions {
+    rootDir: string;
+    maxCacheKb?: number;
+}
+export interface DetectedStack {
+    packageManager: string | "[NEEDS INPUT]";
+    languages: string[];
+    frameworks: string[];
+    scripts: Record<string, string>;
+    entryPoints: string[];
+    notes: string[];
+}
+export interface ProjectState {
+    version: string;
+    generatedAt: string;
+    projectHash: string;
+    trackedFiles: string[];
+}
+export interface CacheStatus {
+    exists: boolean;
+    stale: boolean;
+    reason: string;
+    cachePath: string;
+    statePath: string;
+    projectHash: string;
+    state?: ProjectState;
+}
+export interface HashResult {
+    hash: string;
+    trackedFiles: string[];
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "context-goblin",
+  "version": "0.0.1",
+  "description": "OpenCode plugin that generates a compact, safe project context cache.",
+  "type": "module",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "files": [
+    "dist/src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "smoke:opencode": "bash scripts/smoke-opencode.sh",
+    "benchmark": "tsx scripts/benchmark-context-goblin.ts",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "context"
+  ],
+  "author": "Volodymyr Melnychuk",
+  "license": "MIT",
+  "dependencies": {
+    "@opencode-ai/plugin": "latest"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "tsx": "latest",
+    "typescript": "latest",
+    "vitest": "latest"
+  }
+}