opencode-next-prompt 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 opencode-next-prompt 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/README.md

@@ -0,0 +1,47 @@
+# opencode-next-prompt
+
+Predicts your next message after the assistant replies and shows it at the prompt — accept it with the right arrow (like Claude Code's "next message suggestion").
+
+## Install
+
+Add to `~/.config/opencode/opencode.jsonc` (or the project-level `opencode.json`):
+
+```json
+{
+  "plugin": ["opencode-next-prompt"]
+}
+```
+
+Restart opencode. The package and its dependencies are installed automatically.
+
+## Usage
+
+- After each reply, a suggested next message appears at the input in gray
+- Press **→** while the input is empty to accept it; with text in the input, → keeps its normal cursor behavior
+- Typing hides the suggestion; clearing the input re-shows it
+
+## Config
+
+```json
+{
+  "plugin": [["opencode-next-prompt", {
+    "acceptKey": "right",
+    "position": "left",
+    "timeoutMs": 20000
+  }]]
+}
+```
+
+| Key | Default | Description |
+|---|---|---|
+| `acceptKey` | `right` | Key to accept the suggestion (only effective while the input is empty) |
+| `position` | `left` | Where the suggestion shows: `left` inside the input; `right` below-right of the input |
+| `timeoutMs` | `20000` | Per-prediction timeout; the suggestion is dropped on timeout |
+
+## How it works
+
+After each reply, the plugin predicts your next input in a background session that reuses the conversation prefix — each prediction only processes the new content, so it stays fast regardless of conversation length. The suggestion is written into the input placeholder, so what you see is exactly what gets accepted. The main conversation is never modified.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,149 @@
+import { InputRenderable } from "@opentui/core";
+import { createSuggestionStore } from "./state.js";
+import { createPredictor } from "./predict.js";
+import { createInputEmpty, renderSuggestionPlaceholder, renderSuggestionSlot } from "./ui.js";
+const DEFAULT_OPTIONS = {
+    acceptKey: "right",
+    position: "left",
+    timeoutMs: 20_000,
+};
+const opencodeNextPrompt = async (api, rawOptions) => {
+    const options = { ...DEFAULT_OPTIONS, ...(rawOptions ?? {}) };
+    const store = createSuggestionStore();
+    const currentSessionID = () => {
+        const route = api.route.current;
+        if (route.name !== "session")
+            return undefined;
+        const sessionID = route.params?.sessionID;
+        return typeof sessionID === "string" ? sessionID : undefined;
+    };
+    const promptInputIsEmpty = () => {
+        const editor = api.renderer.currentFocusedEditor;
+        if (!editor || editor instanceof InputRenderable)
+            return false;
+        return editor.editBuffer.getText() === "";
+    };
+    const conversationTurns = (sessionID) => {
+        const result = [];
+        for (const message of api.state.session.messages(sessionID)) {
+            if (message.role !== "user" && message.role !== "assistant")
+                continue;
+            const text = api.state
+                .part(message.id)
+                .map((part) => {
+                if (part.type === "text" && !part.synthetic && !part.ignored) {
+                    return part.text.replace(/<think>[\s\S]*?<\/think>\s*/g, "");
+                }
+                return summarizeToolPart(part);
+            })
+                .join("\n")
+                .trim();
+            if (!text)
+                continue;
+            result.push({ id: message.id, role: message.role, text });
+        }
+        return result;
+    };
+    const lastUserMessageID = (sessionID) => {
+        for (const message of api.state.session.messages(sessionID).toReversed()) {
+            if (message.role === "user")
+                return message.id;
+        }
+        return undefined;
+    };
+    let predictedUserMessageID;
+    const predictor = createPredictor(api.client, api.state.path.directory, options);
+    const maybePredict = async () => {
+        const sessionID = currentSessionID();
+        if (!sessionID)
+            return;
+        const userMessageID = lastUserMessageID(sessionID);
+        if (userMessageID && userMessageID === predictedUserMessageID)
+            return;
+        const turns = conversationTurns(sessionID);
+        if (turns.length === 0)
+            return;
+        const generation = store.beginPredict(sessionID);
+        if (generation === null)
+            return;
+        predictedUserMessageID = userMessageID;
+        const session = api.state.session.get(sessionID);
+        try {
+            const text = await predictor.predict(session?.model, turns);
+            store.commit(generation, sessionID, text);
+        }
+        catch (error) {
+            log(api, "prediction failed", error);
+            store.discard();
+        }
+    };
+    const accept = async () => {
+        const current = store.read();
+        if (current.kind !== "ready")
+            return;
+        try {
+            await api.client.tui.appendPrompt({ text: current.text });
+        }
+        catch (error) {
+            log(api, "append prompt failed", error);
+        }
+    };
+    api.event.on("session.status", (event) => {
+        const { sessionID, status } = event.properties;
+        if (sessionID !== currentSessionID())
+            return;
+        if (status.type === "busy") {
+            store.discard();
+        }
+        else if (status.type === "idle") {
+            if (store.read().kind === "idle")
+                void maybePredict();
+        }
+    });
+    api.event.on("tui.session.select", (event) => {
+        store.discard();
+        void predictor.dispose();
+    });
+    api.event.on("session.compacted", () => {
+        void predictor.dispose();
+    });
+    api.lifecycle.onDispose(() => {
+        void predictor.dispose();
+    });
+    api.keymap.registerLayer({
+        priority: 1000,
+        enabled: () => store.read().kind === "ready",
+        commands: [{ name: "next-prompt.accept", run: () => (promptInputIsEmpty() ? void accept() : undefined) }],
+        bindings: [
+            { key: options.acceptKey, cmd: "next-prompt.accept", preventDefault: false, fallthrough: true },
+        ],
+    });
+    const inputEmpty = options.position === "right" ? createInputEmpty(api) : undefined;
+    api.slots.register({
+        id: "opencode-next-prompt",
+        slots: {
+            session_prompt_right: (ctx, props) => options.position === "right"
+                ? renderSuggestionSlot(ctx, props, store.read, options.acceptKey, inputEmpty)
+                : renderSuggestionPlaceholder(api, props, store.read, options.acceptKey),
+        },
+    });
+};
+function log(api, message, extra) {
+    void api.client.app.log({
+        service: "opencode-next-prompt",
+        level: "info",
+        message,
+        extra: { data: JSON.stringify(extra) },
+    });
+}
+const TOOL_SUMMARY_CHARS = 150;
+function summarizeToolPart(part) {
+    if (part.type !== "tool" || !part.state || part.state.status === "running")
+        return "";
+    const input = JSON.stringify(part.state.input ?? {});
+    const output = part.state.metadata?.output ?? "";
+    const inputText = input.length > 80 ? input.slice(0, 79) + "…" : input;
+    const outputText = output.length > TOOL_SUMMARY_CHARS ? output.slice(0, TOOL_SUMMARY_CHARS - 1) + "…" : output;
+    return `[tool:${part.tool ?? "?"}] ${inputText} → ${outputText || part.state.status || ""}`;
+}
+export default { id: "opencode-next-prompt", tui: opencodeNextPrompt };

package/dist/predict.d.ts

@@ -0,0 +1,17 @@
+import type { OpencodeClient } from "@opencode-ai/sdk/v2";
+export type ConversationTurn = {
+    id: string;
+    role: "user" | "assistant";
+    text: string;
+};
+export type PredictOptions = {
+    timeoutMs: number;
+};
+export type Predictor = {
+    predict(model: {
+        providerID: string;
+        id: string;
+    } | undefined, turns: ConversationTurn[]): Promise<string | null>;
+    dispose(): Promise<void>;
+};
+export declare function createPredictor(client: OpencodeClient, directory: string | undefined, options: PredictOptions): Predictor;

package/dist/predict.js

@@ -0,0 +1,117 @@
+const TITLE = "next-prompt-suggestion";
+const PROMPT = `You are generating a suggested next user message for an AI coding assistant conversation.
+The conversation below is oldest first; the assistant just finished replying.
+
+Goal:
+- Suggest a useful next step that keeps momentum.
+
+Rules:
+- Output exactly one line, 170 characters max. Be concise.
+- Write as the user speaking to the assistant (for example: "Can you...", "Help me...", "Let's...").
+- Match the user's tone and language; keep it natural and human.
+- Prefer a concrete action over a broad question.
+- If the conversation is vague or small-talk, steer toward a practical starter request.
+- If there is no meaningful or appropriate next step to suggest, output exactly: NO_SUGGESTION
+- Avoid corporate or robotic phrasing.
+- Avoid asking multiple discovery questions in one sentence.
+- Do not include quotes, labels, markdown, or explanations.
+
+Examples:
+- Greeting context -> "Can you scan this repo and suggest the best first task to tackle?"
+- Bug-fix context -> "Can you reproduce this bug and propose the smallest safe fix?"
+- Feature context -> "Let's implement this incrementally; start with the MVP version first."
+- Conversation is complete -> "NO_SUGGESTION"
+
+Conversation:
+`;
+const MAX_PREDICTION_CHARS = 170;
+export function createPredictor(client, directory, options) {
+    let sessionID;
+    let predictedTurns = 0;
+    let predictedLastMessageID;
+    let accumulatedChars = 0;
+    const deleteSession = async () => {
+        if (sessionID) {
+            await client.session.delete({ sessionID, directory }).catch(() => { });
+            sessionID = undefined;
+            predictedTurns = 0;
+            predictedLastMessageID = undefined;
+            accumulatedChars = 0;
+        }
+    };
+    return {
+        async predict(model, turns) {
+            const expectedID = turns[predictedTurns - 1]?.id;
+            if (predictedLastMessageID && expectedID && expectedID !== predictedLastMessageID) {
+                await deleteSession();
+            }
+            let delta = turns.slice(predictedTurns);
+            if (delta.length === 0)
+                return null;
+            let input = PROMPT + renderConversation(delta);
+            if (sessionID && accumulatedChars + input.length > MAX_ACCUMULATED_CHARS) {
+                await deleteSession();
+                delta = turns;
+                input = PROMPT + renderConversation(delta);
+            }
+            if (!sessionID) {
+                const created = await client.session.create({ directory, title: TITLE, model });
+                if (created.error)
+                    throw created.error;
+                sessionID = created.data.id;
+            }
+            const result = await withTimeout(client.session.prompt({ sessionID, directory, parts: [{ type: "text", text: input }] }), options.timeoutMs);
+            if (result.error)
+                throw result.error;
+            predictedTurns = turns.length;
+            predictedLastMessageID = turns.at(-1)?.id;
+            accumulatedChars += input.length;
+            return parsePrediction(result.data.parts);
+        },
+        async dispose() {
+            await deleteSession();
+        },
+    };
+}
+const MAX_ASSISTANT_MESSAGES = 10;
+const MAX_ACCUMULATED_CHARS = 80_000;
+function renderConversation(turns) {
+    const assistantCount = turns.reduce((count, turn) => count + (turn.role === "assistant" ? 1 : 0), 0);
+    const skip = Math.max(0, assistantCount - MAX_ASSISTANT_MESSAGES);
+    let skipped = 0;
+    return turns
+        .filter((turn) => {
+        if (turn.role !== "assistant" || skipped >= skip)
+            return true;
+        skipped += 1;
+        return false;
+    })
+        .map((turn) => `${turn.role}: ${turn.text}`)
+        .join("\n");
+}
+function parsePrediction(parts) {
+    const line = parts
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("")
+        .replace(/<think>[\s\S]*?<\/think>\s*/g, "")
+        .split("\n")
+        .map((item) => item.trim())
+        .find((item) => item.length > 0);
+    if (!line)
+        return null;
+    const text = line.replace(/^["'`]+|["'`]+$/g, "");
+    if (!text)
+        return null;
+    const tag = text.toUpperCase().replace(/[\s-]+/g, "_").replace(/[^A-Z_]/g, "");
+    if (tag === "NO_SUGGESTION")
+        return null;
+    return text.length > MAX_PREDICTION_CHARS ? text.slice(0, MAX_PREDICTION_CHARS - 3) + "..." : text;
+}
+function withTimeout(promise, ms) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`prediction timed out after ${ms}ms`)), ms);
+    });
+    return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}

package/dist/state.d.ts

@@ -0,0 +1,19 @@
+export type SuggestionState = {
+    kind: "idle";
+} | {
+    kind: "predicting";
+    sessionID: string;
+    generation: number;
+} | {
+    kind: "ready";
+    sessionID: string;
+    text: string;
+    generation: number;
+};
+export declare function createSuggestionStore(): {
+    read: import("solid-js").Accessor<SuggestionState>;
+    beginPredict(sessionID: string): number | null;
+    commit(generation: number, sessionID: string, text: string | null): void;
+    discard(): void;
+};
+export type SuggestionStore = ReturnType<typeof createSuggestionStore>;

package/dist/state.js

@@ -0,0 +1,25 @@
+import { createSignal } from "solid-js";
+export function createSuggestionStore() {
+    let generation = 0;
+    const [state, setState] = createSignal({ kind: "idle" });
+    return {
+        read: state,
+        beginPredict(sessionID) {
+            if (state().kind !== "idle")
+                return null;
+            generation += 1;
+            setState({ kind: "predicting", sessionID, generation });
+            return generation;
+        },
+        commit(generation, sessionID, text) {
+            const current = state();
+            if (current.kind !== "predicting" || current.generation !== generation)
+                return;
+            setState(text ? { kind: "ready", sessionID, text, generation } : { kind: "idle" });
+        },
+        discard() {
+            generation += 1;
+            setState({ kind: "idle" });
+        },
+    };
+}

package/dist/ui.d.ts

@@ -0,0 +1,10 @@
+import type { JSX } from "@opentui/solid";
+import type { TuiPluginApi, TuiSlotContext } from "@opencode-ai/plugin/tui";
+import type { Accessor } from "solid-js";
+import type { SuggestionState } from "./state.ts";
+export type PromptSlotProps = {
+    session_id: string;
+};
+export declare function renderSuggestionPlaceholder(api: TuiPluginApi, props: PromptSlotProps, state: Accessor<SuggestionState>, acceptKey: string): JSX.Element;
+export declare function createInputEmpty(api: TuiPluginApi): Accessor<boolean>;
+export declare function renderSuggestionSlot(ctx: TuiSlotContext, props: PromptSlotProps, state: Accessor<SuggestionState>, acceptKey: string, inputEmpty: Accessor<boolean>): JSX.Element;

package/dist/ui.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx } from "@opentui/solid/jsx-runtime";
+import { createEffect, createSignal, onCleanup } from "solid-js";
+import { InputRenderable, TextareaRenderable } from "@opentui/core";
+const ARROW_KEYS = {
+    right: "→",
+    left: "←",
+    up: "↑",
+    down: "↓",
+};
+function displayKey(key) {
+    return ARROW_KEYS[key] ?? key;
+}
+export function renderSuggestionPlaceholder(api, props, state, acceptKey) {
+    const apply = () => {
+        const editor = api.renderer.currentFocusedEditor;
+        if (!editor || editor instanceof InputRenderable || !(editor instanceof TextareaRenderable))
+            return;
+        const current = state();
+        editor.placeholder =
+            current.kind === "ready" && current.sessionID === props.session_id
+                ? ` [${displayKey(acceptKey)}] ${current.text}`
+                : null;
+    };
+    createEffect(apply);
+    api.renderer.on("focused_editor", apply);
+    onCleanup(() => {
+        api.renderer.off("focused_editor", apply);
+    });
+    return null;
+}
+export function createInputEmpty(api) {
+    const [inputEmpty, setInputEmpty] = createSignal(true);
+    const apply = () => {
+        const editor = api.renderer.currentFocusedEditor;
+        setInputEmpty(editor === null || (!(editor instanceof InputRenderable) && editor.editBuffer.getText() === ""));
+    };
+    const offs = new Set();
+    const subscribe = (editor) => {
+        if (!editor)
+            return;
+        const handler = () => apply();
+        editor.editBuffer.on("content-changed", handler);
+        editor.editBuffer.on("cursor-changed", handler);
+        offs.add(() => {
+            editor.editBuffer.off("content-changed", handler);
+            editor.editBuffer.off("cursor-changed", handler);
+        });
+    };
+    api.renderer.on("focused_editor", (current) => {
+        offs.forEach((off) => off());
+        offs.clear();
+        subscribe(current);
+        apply();
+    });
+    subscribe(api.renderer.currentFocusedEditor);
+    apply();
+    return inputEmpty;
+}
+export function renderSuggestionSlot(ctx, props, state, acceptKey, inputEmpty) {
+    const current = state();
+    if (current.kind !== "ready" || current.sessionID !== props.session_id || !inputEmpty())
+        return null;
+    return _jsx("text", { fg: ctx.theme.current.textMuted, children: `[${displayKey(acceptKey)}] ${current.text}` });
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "opencode-next-prompt",
+  "version": "0.0.1",
+  "description": "Predicts your next message after the assistant replies in OpenCode — accept it with the right arrow",
+  "type": "module",
+  "exports": {
+    "./tui": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "deno task build",
+    "check": "deno task check"
+  },
+  "engines": {
+    "opencode": ">=1.18.0"
+  },
+  "dependencies": {
+    "@opentui/core": "0.4.5",
+    "@opentui/solid": "0.4.5",
+    "solid-js": "1.9.12"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.0.0",
+    "bun-types": "^1.2.0",
+    "typescript": "^5.5.0"
+  },
+  "keywords": ["opencode-plugin", "tui", "suggestion", "prediction"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lenitain/opencode-next-prompt.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lenitain/opencode-next-prompt/issues"
+  }
+}