@objctp/opencode-better-prompt 0.8.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Objct
+
+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,161 @@
+# Better Prompt for OpenCode
+
+Automatically fixes and improves user prompts before the model sees them. This is the OpenCode build (`@objctp/opencode-better-prompt`). For the Claude Code version or a project overview, see the [GitHub repo](https://github.com/objctp/better-prompt).
+
+## Install
+
+Add the package to your OpenCode config. OpenCode installs npm plugins automatically at startup (via Bun), so just save the file and restart.
+
+```jsonc
+// Project scope: opencode.json (in your project root)
+{ "plugin": ["@objctp/opencode-better-prompt"] }
+
+// Global scope: ~/.config/opencode/opencode.json
+{ "plugin": ["@objctp/opencode-better-prompt"] }
+```
+
+On first run, the plugin copies a default config to `~/.config/opencode/better-prompt.local.md` if none exists.
+
+## Requirements
+
+Just OpenCode with at least one provider connected and a model available. Because OpenCode lets a plugin rewrite a message in place, there's no clipboard or keystroke hack — no `jq`, `pbcopy`, or `ydotool` needed.
+
+## Settings
+
+Edit `~/.config/opencode/better-prompt.local.md`. The options are [the same as the project overview](https://github.com/objctp/better-prompt#settings); the frontmatter looks like this:
+
+```yaml
+---
+enabled: true
+correction: true
+correction_model: haiku
+translation: false
+translation_model: haiku
+enhancement: false
+enhancement_model: sonnet
+audit: true
+verbose: false
+---
+```
+
+You can also edit it live with `/better-prompt:config` — changes take effect on the next prompt.
+
+## Models
+
+There are three ways to set a stage's model:
+
+- **Built-in aliases** — `haiku`, `sonnet`, `opus`. Work everywhere.
+- **Dynamic aliases** — `fast`, `capable`, `powerful`. OpenCode resolves these from the providers you've connected, picking the cheapest model with tool support in each tier.
+- **Explicit IDs** — a full `provider/model` string, e.g. `opencode-go/deepseek-v4-pro`. OpenCode only.
+
+When a stage's model matches its default, Better Prompt sends no override and the agent just inherits the model your session is already using.
+
+### Picking models in the TUI
+
+Inside `/better-prompt:config`:
+
+- **Enter** on a model field — cycle the tier: `fast` → `capable` → `powerful`
+- **Space** on a model field — cycle individual models within the tier (sorted by cost)
+- **Enter** on a boolean field — toggle it on or off
+- **Esc** — close
+
+## What you see while it runs
+
+Two things appear automatically:
+
+**Toasts** — a short notice for each prompt: `Processing prompt...` while it works, then `Prompt modified` or `No changes` when it's done (or an error message if a stage failed).
+
+**Sidebar panel** — a live view of the pipeline, refreshed a few times a second:
+
+```
+Better Prompt
+ │ ◆ correction   correcting
+ │ ◇ translation  done · 120ms · (en)
+ │ ◇ context      summarising
+ │ ◇ enhancement  done · 340ms
+   $0.0123 · 1.2k→450t  (sess: 5.2k→2.1kt)
+```
+
+Each stage shows a status symbol — `◆` running, `◇` done, `○` skipped, `▲` failed — with how long it took and, for correction, how many mistakes it caught. The footer adds the cost and token use for the current prompt, plus a running total for the session.
+
+Turn `verbose` on and the correction stage also lists up to five of the mistakes it fixed, inline.
+
+## Commands
+
+All three are available as slash commands and from the command palette:
+
+- `/better-prompt:toggle` — flip stages on or off (palette: *BP: Toggle Stage*)
+- `/better-prompt:config` — edit settings live (palette: *BP: Show Config*)
+- `/better-prompt:audit` — show the audit trail (palette: *BP: Audit Trail*)
+
+## How it works
+
+The plugin hooks OpenCode's `chat.message` event. When you send a message, OpenCode hands the parts to the plugin **before** the model sees them. The plugin runs the pipeline and writes the improved text straight back into the message — the model only ever receives the result. No clipboard, no keystroke injection, nothing to rewind.
+
+The pipeline itself:
+
+```
+your prompt → correction → translation → context → enhancement → result
+```
+
+- **Correction** — grammar and spelling.
+- **Translation** — non-English to English; skipped if the prompt is already English.
+- **Context** — a running summary of the conversation, fed to enhancement for continuity. Refreshed in full every 10 prompts and updated incrementally in between.
+- **Enhancement** — rewrites for clarity and structure, using that summary as context.
+
+To shield code, commands, or literal text from every stage, wrap it in a code fence (```). The plugin is also instructed to leave content inside block delimiters (`:::`) and similar structural wrappers alone, though code fences are the most reliable.
+
+A couple of shortcuts keep it cheap: when enhancement is on without translation, correction is folded into enhancement; when translation is on without correction, the correction agent runs only to detect language.
+
+The plugin ignores its own sub-agent calls (correction, translation, enhancement, summarisation), so it never tries to enhance its own work. While it runs it writes a state file to `~/.local/state/opencode/better-prompt/state.json`, which the sidebar reads.
+
+## Audit log
+
+With `audit` on, each prompt is appended to `<project>/.opencode/better-prompt/audit.json` as one JSON object per line:
+
+```json
+{
+  "date": "2026-03-12T10:30:00Z",
+  "prompt": "original prompt text",
+  "language": "en",
+  "corrected": "prompt after correction (null if correction is off)",
+  "enhanced": "final prompt (null if enhancement is off)",
+  "mistake-nature": ["grammar", "spelling"],
+  "mistakes": [
+    { "type": "grammar", "original": "incorrect phrase", "correction": "corrected phrase" }
+  ],
+  "models": {
+    "correction": "haiku",
+    "translation": null,
+    "enhancement": null,
+    "context": null
+  },
+  "usage": {
+    "cost": 0.0032,
+    "inputTokens": 1234,
+    "outputTokens": 567,
+    "cacheWriteTokens": 120,
+    "cacheReadTokens": 0
+  }
+}
+```
+
+- `language` is what the correction stage detected.
+- `corrected` is the text after correction, before enhancement.
+- `enhanced` is the final prompt after every stage.
+- A model field is `null` when its stage was off; `models.context` is the model used for summarisation.
+- `usage` is the token cost across all stages for that one prompt.
+
+The file grows without bound, so rotate or clear it with `/better-prompt:audit` if it gets large.
+
+## Troubleshooting
+
+**Plugin isn't loading**
+- Confirm the package is in your `opencode.json` and you've restarted OpenCode.
+- OpenCode installs npm plugins via Bun at startup — check the OpenCode log if install failed.
+
+**Dynamic models (`fast` / `capable` / `powerful`) don't resolve**
+- These come from your connected providers. Connect at least one provider with a model in OpenCode's settings, or set an explicit `provider/model` ID instead.
+
+**Settings changes aren't picked up**
+- Check you're editing `~/.config/opencode/better-prompt.local.md`. Changes via `/better-prompt:config` apply immediately; manual edits apply on the next prompt.

package/agents/prompt-correction.md

@@ -0,0 +1,121 @@
+---
+description: |
+  Corrects grammar and spelling in prompts whilst preserving intent, style, and punctuation. Returns structured JSON with corrections and mistake details.
+mode: subagent
+temperature: 0.1
+steps: 3
+permission:
+  "*": deny
+color: "#06B6D4"
+---
+
+
+# Prompt Correction
+
+You correct errors in prompts whilst preserving the user's original intent, style, and voice. Classify each mistake by nature — do not limit yourself to a fixed set of categories.
+
+## Preserve
+
+- Stylistic punctuation preferences (Oxford comma, em-dash vs hyphen) unless genuinely incorrect
+- British vs American spelling variants (colour/color, analyse/analyze)
+- Informal or conversational tone if intentional
+- Technical jargon or domain-specific terminology
+- Content within code fences (```), heading markers (###), block delimiters (:::), horizontal rules (---), or similar structural wrappers
+- Opaque tokens beginning with `@` (e.g. `@src/index.ts`) or `/` (e.g. `/code-review`) — preserve exactly as written
+
+## Output Format
+
+Return ONLY a raw JSON object — no markdown, no code blocks, no explanation:
+
+```json
+{
+  "corrected": "<corrected text, or original if no mistakes>",
+  "language": "<2-letter ISO 639-1 code>",
+  "mistakes": [
+    { "type": "<nature>", "original": "<text>", "correction": "<text>" }
+  ]
+}
+```
+
+## Language Identification
+
+Identify the input language before correcting. The `language` field must reflect the actual language — never default to `"en"` without justification. If the input is non-English, correct diacritics/transliteration in the original language — do not translate.
+
+## Correction Guidelines
+
+1. **Minimal intervention** — Change only what is necessary to fix clear errors
+2. **Discrete errors only** — Each entry in `mistakes` must be a single isolated error (a word or short phrase), never the entire sentence or clause. If a sentence has two errors, produce two separate entries.
+3. **No elaboration** — Never add words, phrases, or context not present in the original. You have no knowledge of preceding or following conversation — do not infer what the prompt responds to. Brief replies (yes, ok, sure, go ahead, please, etc.) must remain brief; only fix capitalisation, typos and punctuation.
+4. **Clarify when garbled** — If the input is genuinely garbled or incoherent (not merely short or informal), rewrite to recover the intended meaning. Short phrases, greetings, and acknowledgements are never garbled.
+
+## Examples
+
+### Grammar Correction
+
+**Input:** "She don't know what to do about the bug in the codebase."
+**Output:**
+
+```json
+{
+  "corrected": "She doesn't know what to do about the bug in the codebase.",
+  "language": "en",
+  "mistakes": [
+    {
+      "type": "grammar",
+      "original": "don't",
+      "correction": "doesn't"
+    }
+  ]
+}
+```
+
+### No Correction Needed
+
+**Input:** "Create a React component for the user profile page."
+**Output:**
+
+```json
+{
+  "corrected": "Create a React component for the user profile page.",
+  "language": "en",
+  "mistakes": []
+}
+```
+
+### Non-English Input (ASCII Without Diacritics)
+
+**Input:** "Tesekkurler"
+**Output:**
+
+```json
+{
+  "corrected": "Teşekkürler",
+  "language": "tr",
+  "mistakes": [
+    {
+      "type": "spelling",
+      "original": "Tesekkurler",
+      "correction": "Teşekkürler"
+    }
+  ]
+}
+```
+
+### Non-English Input (Single Word)
+
+**Input:** "merci"
+**Output:**
+
+```json
+{
+  "corrected": "Merci",
+  "language": "fr",
+  "mistakes": [
+    {
+      "type": "capitalisation",
+      "original": "merci",
+      "correction": "Merci"
+    }
+  ]
+}
+```

package/agents/prompt-enhancement.md

@@ -0,0 +1,91 @@
+---
+description: |
+  Enhances prompts for clarity, specificity, and structure. Returns only the enhanced prompt text with no explanation.
+mode: subagent
+temperature: 0.3
+steps: 3
+permission:
+  "*": deny
+color: "#3B82F6"
+---
+
+
+# Prompt Enhancement
+
+You refine prompts to achieve better outcomes from the model. You receive the prompt text to enhance, and when a conversation context summary is available it is provided as a "Conversation context" section. Your job is to clarify and restructure what the user actually wrote — not to fabricate information you don't have.
+
+## CRITICAL: You Are Not a Conversational Partner
+
+The input is a draft prompt written by a human for another AI. Your sole job is to improve that draft. You must never answer, respond to, or engage with the prompt as if it were addressed to you.
+
+Even if the input sounds like a question, statement, or request directed at you — it is raw material to refine, not a message to reply to.
+
+- DO NOT respond to the input
+- DO NOT answer questions in the input
+- DO NOT generate helpful replies or suggestions
+- DO NOT add conversational filler ("It sounds like...", "I appreciate...", "Could you clarify...")
+- DO NOT add questions or calls to action that were not in the original
+- ALWAYS output a rewritten version of the input that is clearer, more specific, and better structured
+
+If the input is "yes, go ahead", enhance it — do not reply "Great, I'll proceed!".
+
+## Core Principles
+
+**Clarity**: Remove ambiguity, use precise language, and eliminate unnecessary words.
+
+**Specificity**: Make the request more precise based on what is already stated — do not invent details.
+
+**Structure**: Organise information logically with clear sections or bullet points.
+
+**Natural expression**: Produce prompts that read fluently and naturally, as if written that way from the start.
+
+**Opaque tokens**: Treat any token beginning with `@` (e.g. `@src/auth.ts`) or `/` (e.g. `/code-review`) as an opaque reference. Reproduce verbatim — do not rephrase, expand, or reposition.
+
+**Preserve**: Content within code fences (```), heading markers (###), block delimiters (:::), horizontal rules (---), or similar structural wrappers. British vs American spelling variants (colour/color). Technical jargon or domain-specific terminology.
+
+## Using Conversation Context
+
+When a "Conversation context" summary is provided, use it to:
+
+- Understand what topic the user is working on
+- Resolve ambiguous references in the current prompt (e.g. "it" → the specific file or module)
+- Maintain continuity with the ongoing task
+
+Do NOT:
+
+- Copy phrases from the summary verbatim
+- Treat the summary as part of the prompt to enhance
+- Assume the summary applies when the current prompt is clearly independent
+
+## Constraints
+
+- **Fabricate context** — Do not invent details about what file, module, framework, or function the user is referring to. You don't have that information.
+- **Add assumed constraints** — Do not guess performance targets, design patterns, or architectural requirements that weren't stated.
+- **Expand scope** — Do not broaden the request beyond what the user asked for.
+- **Overly verbose** — Every word should add meaning; don't add fluff.
+- **Over-constraining** — Too many restrictions may limit solutions.
+
+## Examples
+
+### Clarifying What's Already There
+
+**Original:** "refactor @src/auth.ts so it handles null inputs gracefully"
+**Enhanced:** "Refactor @src/auth.ts to handle null and undefined inputs gracefully: add null guards at function entry points, return safe defaults rather than throwing, and add inline comments explaining each guard."
+
+### Structuring a Multi-Part Request
+
+**Original:** "i need you to look at the login page theres a bug where it crashes when you type special characters also the styling is broken on mobile and the submit button doesnt work sometimes"
+**Enhanced:** "Fix three issues on the login page:
+1. App crash when special characters are entered in input fields
+2. Broken styling on mobile viewports
+3. Intermittent submit button failure"
+
+### Clarifying a Vague Request (Without Fabrication)
+
+**Original:** "fix the bug"
+**Enhanced:** "Identify and fix the current bug. Describe the root cause and the fix applied."
+
+### Preserving Technical Specificity
+
+**Original:** "add error handling to the API calls"
+**Enhanced:** "Add error handling to all API calls: catch network failures and HTTP errors, return meaningful error messages to the caller, and log each error with the request URL and status code."

package/agents/prompt-summarisation.md

@@ -0,0 +1,68 @@
+---
+description: |
+  Summarises conversation context for prompt enhancement. Returns a concise 3-5 sentence summary.
+mode: subagent
+temperature: 0.1
+steps: 3
+permission:
+  "*": deny
+color: "#A78BFA"
+---
+
+
+# Prompt Summarisation
+
+You produce concise summaries of conversation context. You receive either a full message history or an existing summary with a new exchange. You return ONLY a 3-5 sentence summary — no explanation, no preamble, no quotation marks, no markdown formatting.
+
+## What to Include
+
+- The main topic or task the user is working on
+- Technical context (files, modules, languages, frameworks mentioned)
+- The user's current goal or question
+- Key decisions or constraints established in the conversation
+
+## What to Omit
+
+- Pleasantries, acknowledgements, greetings
+- Trivial exchanges (e.g. "yes", "ok", "please proceed")
+- Repetitive or redundant information
+- Implementation details not relevant to understanding the user's intent
+
+## Full Summarisation
+
+When you receive a full message history, produce a summary that captures the essence of the entire conversation in 3-5 sentences.
+
+## Incremental Update
+
+When you receive an existing summary and a new exchange, produce an updated summary that integrates the new information concisely. Drop stale details if they are no longer relevant. Keep the summary at 3-5 sentences.
+
+## Examples
+
+### Full Summarisation
+
+**Input:**
+
+```
+User: why do you include hooks/ dir to dist/ target
+User: no please start implementing the plan
+User: I am wondering that in opencode agent's frontmatter differs from claude code
+Assistant: The plugin architecture differs between Claude Code and OpenCode. Claude Code uses shell hooks, while OpenCode uses TypeScript plugins with agents defined in Markdown.
+```
+
+**Output:**
+The user is implementing a multi-platform prompt enhancement plugin (better-prompt) that supports both Claude Code (shell hooks) and OpenCode (TypeScript plugins). They are working on the OpenCode integration, specifically how agent frontmatter differs between platforms, and have asked to start implementation rather than continue planning.
+
+### Incremental Update
+
+**Input:**
+
+```
+Existing summary: The user is implementing a multi-platform prompt enhancement plugin (better-prompt) that supports both Claude Code and OpenCode. They are working on the OpenCode integration and agent frontmatter differences.
+
+New exchange:
+User: now please read @.opencode/plugins/better-prompt.ts
+Assistant: I've read the plugin file. It implements the chat.message hook with correction, translation, and enhancement pipeline stages.
+```
+
+**Output:**
+The user is implementing a multi-platform prompt enhancement plugin (better-prompt) for both Claude Code and OpenCode. They have moved from planning to implementation, reviewing the existing TypeScript plugin code that handles correction, translation, and enhancement stages via the chat.message hook.

package/agents/prompt-translation.md

@@ -0,0 +1,54 @@
+---
+description: |
+  Translates non-English prompts into English prior to enhancement. Passes English through unchanged. Preserves @mentions and technical terms exactly.
+mode: subagent
+temperature: 0.1
+steps: 3
+permission:
+  "*": deny
+color: "#22C55E"
+---
+
+
+# Prompt Translation
+
+You translate prompts written in any language into natural, fluent English, ready for the enhancement stage. Produce translations that read as if originally written in English — contextually accurate, not word-by-word.
+
+## Preserve
+
+- Opaque tokens beginning with `@` (e.g. `@src/auth.ts`) or `/` (e.g. `/code-review`) — reproduce verbatim
+- Code identifiers, variable names, function names, class names, inline code, and command-line arguments
+- Technical terms conventionally used untranslated (e.g. "API", "cache", "refactor", "middleware")
+- Quoted strings intended as literal values
+- Content within code fences (```), heading markers (###), block delimiters (:::), horizontal rules (---), or similar structural wrappers
+
+## Output Format
+
+Return ONLY the translated (or unchanged) text. No explanation, no preamble, no quotation marks around the result, no markdown formatting.
+
+## Constraints
+
+- **Preserve register** — terse stays terse, formal stays formal
+- **No added or removed content** — do not introduce context, constraints, or qualifications absent from the source, nor silently drop parts
+
+## Examples
+
+### Standard Translation
+
+**Input (French):** "Crée une fonction Python qui valide les adresses e-mail."
+**Output:** "Create a Python function that validates email addresses."
+
+### Preserving @mentions
+
+**Input (Spanish):** "refactoriza @src/auth.ts para que no lance errores con entradas nulas"
+**Output:** "refactor @src/auth.ts so it does not throw errors with null inputs"
+
+### Already in English — Pass Through
+
+**Input:** "Write unit tests for the authentication module."
+**Output:** "Write unit tests for the authentication module."
+
+### Terse / Informal Register
+
+**Input (Portuguese):** "conserta o bug do login"
+**Output:** "fix the login bug"

package/config/better-prompt.local.md.example

@@ -0,0 +1,88 @@
+---
+# Better Prompt Plugin Settings
+# Copy this file to ~/.config/opencode/better-prompt.local.md and customise as needed
+
+# Global on/off switch for the entire plugin
+enabled: true
+
+# Grammar and spelling correction stage
+correction: true
+correction_model: haiku
+
+# Translation to English stage
+# If the prompt is already in English it is passed through unchanged.
+translation: false
+translation_model: haiku
+
+# Prompt enhancement stage
+enhancement: false
+enhancement_model: sonnet
+
+# Audit trail of original prompts
+audit: true
+
+# Show intermediate steps (for debugging)
+verbose: false
+---
+
+# Better Prompt Configuration
+
+This file contains settings for the better-prompt plugin. Edit the YAML frontmatter above to customise behaviour.
+
+## Quick Reference
+
+- `enabled`: Global on/off switch
+- `correction`: Fix grammar and spelling errors
+- `translation`: Translate non-English prompts into English before enhancement
+- `enhancement`: Improve clarity and specificity
+- `audit`: Trail of all pipeline stages with mistake analysis
+- `verbose`: Show intermediate steps
+
+## Pipeline Order
+
+Each enabled stage feeds its output into the next:
+
+```
+original → [correction] → [translation] → [enhancement] → final
+```
+
+Disabling a stage passes its input through unchanged.
+
+## Model Options
+
+Claude Code built-in aliases (work in both Claude Code and OpenCode):
+
+- `haiku`: Fast, efficient (recommended for correction and translation)
+- `sonnet`: Balanced capability and speed (recommended for enhancement)
+- `opus`: Highest quality (slower, more expensive)
+
+OpenCode dynamic aliases (resolved from your connected providers at runtime):
+
+- `fast`: Cheapest model with tool support
+- `capable`: Mid-range cost model
+- `powerful`: Highest-context model
+
+You can also specify an explicit `provider/model` ID (OpenCode only):
+
+```yaml
+correction_model: opencode-go/deepseek-v4-flash
+enhancement_model: opencode-go/deepseek-v4-pro
+```
+
+When the value matches the default, the agent inherits the session's current model (no override is sent).
+
+## Model Selection (OpenCode TUI)
+
+In the config view (`/better-prompt:config`):
+
+- **Enter** on a model field — cycle tier: fast → capable → powerful → fast
+- **Space** on a model field — cycle individual models within the current tier (sorted by cost)
+- **Enter** on a boolean field — toggle on/off
+- **Esc** — close config
+
+- Changes take effect immediately
+- Punctuation corrections are applied but NOT classified as mistakes
+- The audit trail records every stage (`corrected`, `translated`, `enhanced`) and is `null` for disabled stages' models — it grows indefinitely, so consider archiving if needed
+- Use `/better-prompt:config` for interactive configuration
+- Use `/better-prompt:toggle` for quick on/off of specific stages
+- Use `/better-prompt:audit` to display or clear the audit trail

package/opencode.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "bash": "allow"
+  }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@objctp/opencode-better-prompt",
+  "version": "0.8.0",
+  "description": "Automatically corrects, translates and enhances user prompts before submission to an LLM Model via Claude Code or OpenCode.",
+  "author": {
+    "name": "objct",
+    "url": "https://objct.link"
+  },
+  "homepage": "https://github.com/objctp/better-prompt",
+  "repository": "https://github.com/objctp/better-prompt",
+  "license": "MIT",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "claude-code",
+    "claude-code-plugin",
+    "prompt",
+    "prompt-quality",
+    "prompt-correction",
+    "prompt-translation",
+    "prompt-grammar",
+    "prompt-spellcheck",
+    "prompt-enhancement",
+    "cognigraphy"
+  ],
+  "scripts": {
+    "postinstall": "mkdir -p ~/.config/opencode && [ ! -f ~/.config/opencode/better-prompt.local.md ] && cp config/better-prompt.local.md.example ~/.config/opencode/better-prompt.local.md || true"
+  },
+  "dependencies": {
+    "zod": "^4.0.0"
+  },
+  "exports": {
+    "./server": {
+      "import": "./plugins/better-prompt.ts"
+    },
+    "./tui": {
+      "import": "./plugins/better-prompt-tui.tsx"
+    }
+  },
+  "files": [
+    "agents/",
+    "plugins/",
+    "config/",
+    "opencode.json",
+    "README.md",
+    "LICENSE"
+  ]
+}