opencode-queue 0.4.0 → 0.6.0

package/README.md

@@ -7,8 +7,10 @@ This plugin adds a real `/queue` slash command that keeps the current run focuse
 ## What it does
 
 - Queues normal prompts entered while a session is busy
-- Queues slash commands like `/queue /review` and `/queue /commit`
+- Queues prompts with either `/queue prompt` or `prompt /queue`
+- Queues slash commands with either `/queue /review` or `/review /queue`
 - Hides queued placeholders from both the UI transcript and the running agent
+- Preserves the selected agent, model, and thinking variant for queued input
 - Replays queued input in order once the session becomes idle
 - Replays queued commands as a visible `/command` message before executing them
 - Registers `/queue` as a real OpenCode slash command
@@ -37,6 +39,8 @@ While the agent is busy:
 /queue continue after the current task finishes
 /queue /review
 /queue /commit
+continue after the current task finishes /queue
+/review /queue
 /queue list
 /queue clear
 ```
@@ -46,6 +50,8 @@ When the session is idle:
 ```text
 /queue hello
 /queue /review
+hello /queue
+/review /queue
 /queue
 ```
 
@@ -55,9 +61,11 @@ Queued items stay hidden while the current run is still working, then replay aut
 
 - This is a `/queue` plugin, not a keyboard shortcut plugin. OpenCode plugins cannot currently register custom TUI keybindings.
 - Idle `/queue some text` is treated like a normal prompt with the `/queue` prefix removed.
+- Idle `some text /queue` and `/command /queue` run immediately with the trailing `/queue` removed.
 - Idle `/queue /command` immediately runs the nested command.
 - `/queue` and `/queue list` show the in-memory queue for the current session.
 - `/queue clear` drops all currently queued items for the current session.
+- OpenCode shell mode is not supported because it uses a separate shell execution path outside normal prompt and slash-command handling.
 
 ## License
 

package/index.ts

@@ -1,31 +1,48 @@
 import type { Plugin } from "@opencode-ai/plugin"
-import type {
-  AgentPartInput,
-  FilePart,
-  FilePartInput,
-  SubtaskPartInput,
-  TextPart,
-  TextPartInput,
-} from "@opencode-ai/sdk"
+import type { AgentPartInput, FilePart, FilePartInput, SubtaskPartInput, TextPart, TextPartInput } from "@opencode-ai/sdk"
 
 const QUEUE = /^\/queue(?:\s+([\s\S]*))?$/
-const COMMAND = /^\/(\S+)(?:\s+([\s\S]*))?$/
+const SUFFIX = /^([\s\S]*?)\s+\/queue\s*$/
+const CMD = /^\/(\S+)(?:\s+([\s\S]*))?$/
 const HANDLED = "__QUEUE_HANDLED__"
 
 type InputPart = TextPartInput | FilePartInput | AgentPartInput | SubtaskPartInput
-type Info = { agent: string; model: { providerID: string; modelID: string } }
-type Item = { info: Info; text: string; parts?: InputPart[]; command?: string; arguments?: string; files?: FilePartInput[] }
+type Model = { providerID: string; modelID: string }
+type Meta = { variant?: string; controls?: string[]; fast?: boolean }
+type Info = { agent: string; model: Model } & Meta
+type Msg = { info: { role: string; agent?: string; mode?: string; model?: Model; providerID?: string; modelID?: string } & Meta }
+
+type Item =
+  | { kind: "prompt"; info: Info; text: string; parts: InputPart[] }
+  | { kind: "command"; info: Info; text: string; cmd: string; args: string; files: FilePartInput[] }
+
+type Op =
+  | { kind: "list" }
+  | { kind: "clear" }
+  | { kind: "prompt"; text: string; body: string }
+  | { kind: "command"; text: string; cmd: string; args: string }
 
 const label = (body: string, files: number) => {
   const text = body.trim() || `${files} attachment${files === 1 ? "" : "s"}`
   return text.length > 72 ? `${text.slice(0, 69)}...` : text
 }
 
-const parseCommand = (body: string) => {
-  const match = body.trim().match(COMMAND)
-  return match ? { command: match[1], arguments: match[2] ?? "" } : undefined
+const parse = (body: string, files = 0): Op => {
+  const text = body.trim()
+  if (!files) {
+    if (!text || text === "list") return { kind: "list" }
+    if (text === "clear") return { kind: "clear" }
+  }
+
+  const match = text.match(CMD)
+  if (match) return { kind: "command", text, cmd: match[1], args: match[2] ?? "" }
+  return { kind: "prompt", text: label(body, files), body }
 }
 
+const trailing = (text: string) => (text.trim() === "/queue" ? "" : text.match(SUFFIX)?.[1])
+const strip = (text: string) => trailing(text) ?? text
+const queued = (text: string) => text.match(QUEUE)?.[1] ?? trailing(text)
+
 export const QueuePlugin: Plugin = async ({ client }) => {
   const queue = new Map<string, Item[]>()
   const hidden = new Set<string>()
@@ -35,89 +52,78 @@ export const QueuePlugin: Plugin = async ({ client }) => {
   const toast = (message: string, variant: "info" | "error", duration = 2500) =>
     client.tui.showToast({ body: { message, variant, duration } }).catch(() => undefined)
 
-  const hide = (id: string, text: TextPart) => {
-    hidden.add(id)
-    text.text = ""
-    text.synthetic = true
-    text.ignored = true
+  const stop = async (message: string, variant: "info" | "error" = "info", duration = 5000): Promise<never> => {
+    await toast(message, variant, duration)
+    throw new Error(HANDLED)
   }
 
-  const enqueue = (sid: string, item: Item) => {
-    const items = queue.get(sid)
-    if (items) items.push(item)
-    else queue.set(sid, [item])
+  const hide = (id: string, part: TextPart) => {
+    hidden.add(id)
+    Object.assign(part, { text: "", synthetic: true, ignored: true })
   }
 
-  const summary = (sid: string) => {
-    const items = queue.get(sid) ?? []
-    if (!items.length) return "Queue is empty"
-    return items.map((item, i) => `${i + 1}. ${item.text}`).join("\n")
-  }
+  const files = (parts: { type: string }[]) => parts.filter((part): part is FilePart => part.type === "file").map((part) => ({ ...part }))
+
+  const manage = (sid: string, op: Extract<Op, { kind: "list" | "clear" }>) => {
+    if (op.kind === "list") return (queue.get(sid) ?? []).map((item, i) => `${i + 1}. ${item.text}`).join("\n") || "Queue is empty"
 
-  const clear = (sid: string) => {
     const count = queue.get(sid)?.length ?? 0
     queue.delete(sid)
     return count ? `Cleared ${count} queued item${count === 1 ? "" : "s"}` : "Queue is empty"
   }
 
-  const replay = async (sid: string, item: Item) => {
-    if (!item.command || item.arguments === undefined) {
-      if (!item.parts?.length) {
-        console.warn("QueuePlugin skipped queued item without replayable content")
-        return
+  const latest = async (sid: string): Promise<Info | undefined> => {
+    const result = await client.session.messages({ path: { id: sid }, query: { limit: 100 } }).catch((error) => {
+      console.warn("QueuePlugin could not inspect session messages for queued placeholder metadata", error)
+      return []
+    })
+
+    for (const msg of [...(Array.isArray(result) ? result : (result.data ?? []))].reverse() as Msg[]) {
+      if (msg.info.role === "user" && msg.info.agent && msg.info.model) return { agent: msg.info.agent, model: msg.info.model, variant: msg.info.variant, controls: msg.info.controls, fast: msg.info.fast }
+      if (msg.info.role === "assistant" && (msg.info.agent || msg.info.mode) && msg.info.providerID && msg.info.modelID) {
+        return { agent: msg.info.agent ?? msg.info.mode!, model: { providerID: msg.info.providerID, modelID: msg.info.modelID }, variant: msg.info.variant, controls: msg.info.controls, fast: msg.info.fast }
       }
+    }
+
+    return undefined
+  }
+
+  const opts = (info: Info) => ({ agent: info.agent, model: info.model, variant: info.variant, controls: info.controls, fast: info.fast })
 
-      await client.session.prompt({
+  const prompt = (sid: string, info: Info, parts: InputPart[], noReply?: boolean) => client.session.prompt({ path: { id: sid }, body: { ...opts(info), noReply, parts } as any })
+
+  const replay = async (sid: string, item: Item) => {
+    if (item.kind === "command") {
+      await prompt(sid, item.info, [{ type: "text", text: item.text }, ...item.files], true)
+      await client.session.command({
         path: { id: sid },
         body: {
-          agent: item.info.agent,
-          model: item.info.model,
-          parts: item.parts.map((part) => ({ ...part, id: undefined })),
-        },
+          ...opts(item.info),
+          model: `${item.info.model.providerID}/${item.info.model.modelID}`,
+          command: item.cmd,
+          arguments: item.args,
+          parts: item.files,
+        } as any,
       })
       return
     }
 
-    await client.session.prompt({
-      path: { id: sid },
-      body: {
-        agent: item.info.agent,
-        model: item.info.model,
-        noReply: true,
-        parts: [{ type: "text", text: item.text }, ...(item.files ?? [])],
-      },
-    })
-
-    await client.session.command({
-      path: { id: sid },
-      body: {
-        agent: item.info.agent,
-        model: `${item.info.model.providerID}/${item.info.model.modelID}`,
-        command: item.command,
-        arguments: item.arguments,
-        parts: item.files,
-      } as any,
-    })
+    if (item.parts.length) {
+      return prompt(sid, item.info, item.parts.map((part) => ({ ...part, id: undefined })))
+    }
+    console.warn("QueuePlugin skipped queued item without replayable content")
   }
 
   const flush = async (sid: string) => {
-    if (flushing.has(sid)) return
-
     const list = queue.get(sid)
-    if (!list?.length) return
+    if (flushing.has(sid) || !list?.length) return
 
     flushing.add(sid)
-
     try {
-      while (list.length) {
-        const item = list.shift()
-        if (!item) break
-        await replay(sid, item)
-      }
+      while (list.length) await replay(sid, list.shift()!)
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error)
       console.error("QueuePlugin failed to flush queued input", error)
-      await toast(`Queue failed: ${message}`, "error")
+      await toast(`Queue failed: ${error instanceof Error ? error.message : String(error)}`, "error")
     } finally {
       if (list.length) queue.set(sid, list)
       else queue.delete(sid)
@@ -128,10 +134,7 @@ export const QueuePlugin: Plugin = async ({ client }) => {
   return {
     config: async (cfg) => {
       cfg.command ??= {}
-      cfg.command.queue = {
-        template: "",
-        description: "Queue input until the session is idle",
-      }
+      cfg.command.queue = { template: "", description: "Queue input until the session is idle" }
     },
     event: async ({ event }) => {
       if (event.type !== "session.status") return
@@ -146,90 +149,81 @@ export const QueuePlugin: Plugin = async ({ client }) => {
       await flush(sid)
     },
     "command.execute.before": async (input, output) => {
-      if (input.command !== "queue") return
-
+      const sid = input.sessionID
       const body = input.arguments ?? ""
-      const text = body.trim()
-      const files = output.parts.filter((part): part is FilePart => part.type === "file").map((part) => ({ ...part }))
+      const parts = files(output.parts)
 
-      if ((!text || text === "list" || text === "clear") && !files.length) {
-        await toast(text === "clear" ? clear(input.sessionID) : summary(input.sessionID), "info", 5000)
-        throw new Error(HANDLED)
-      }
+      if (input.command !== "queue") {
+        const args = trailing(body)
+        if (args === undefined) return
 
-      if (!busy.has(input.sessionID)) {
-        const cmd = parseCommand(body)
-        if (!cmd) {
-          output.parts.length = 0
-          output.parts.push({ type: "text", text: body } as any, ...files)
+        if (!busy.has(sid)) {
+          for (const part of output.parts) if (part.type === "text") part.text = strip(part.text)
           return
         }
 
-        await client.session.prompt({
-          path: { id: input.sessionID },
-          body: {
-            noReply: true,
-            parts: [{ type: "text", text }, ...files],
-          } as any,
-        })
-        await client.session.command({
-          path: { id: input.sessionID },
-          body: {
-            command: cmd.command,
-            arguments: cmd.arguments,
-            parts: files,
-          } as any,
-        })
-        throw new Error(HANDLED)
+        output.parts.length = 0
+        output.parts.push({ type: "text", text: `/queue /${input.command}${args.trim() ? ` ${args.trim()}` : ""}` } as any, ...parts)
+        return
+      }
+
+      const op = parse(body, parts.length)
+
+      if (op.kind === "list" || op.kind === "clear") return stop(manage(sid, op))
+
+      if (!busy.has(sid)) {
+        if (op.kind === "command") {
+          await client.session.prompt({ path: { id: sid }, body: { noReply: true, parts: [{ type: "text", text: op.text }, ...parts] } })
+          await client.session.command({ path: { id: sid }, body: { command: op.cmd, arguments: op.args, parts } as any })
+          throw new Error(HANDLED)
+        }
+
+        output.parts.length = 0
+        output.parts.push({ type: "text", text: op.body } as any, ...parts)
+        return
       }
 
       output.parts.length = 0
-      output.parts.push({ type: "text", text: `/queue ${body}` } as any, ...files)
+      output.parts.push({ type: "text", text: `/queue ${body}` } as any, ...parts)
     },
-    "chat.message": async ({ sessionID }, output) => {
+    "chat.message": async (input, output) => {
+      const sid = input.sessionID
       const text = output.parts.find((part): part is TextPart => part.type === "text" && !part.synthetic)
       if (!text) return
 
-      const body = text.text.match(QUEUE)?.[1]
+      const body = queued(text.text)
       if (body === undefined) return
 
-      const files = output.parts.filter((part): part is FilePart => part.type === "file")
-      const trimmed = body.trim()
+      const parts = files(output.parts)
+      const op = parse(body, parts.length)
 
-      if ((!trimmed || trimmed === "list" || trimmed === "clear") && !files.length) {
+      if (op.kind === "list" || op.kind === "clear") {
         hide(output.message.id, text)
-        await toast(trimmed === "clear" ? clear(sessionID) : summary(sessionID), "info", 5000)
+        await toast(manage(sid, op), "info", 5000)
         return
       }
 
-      if (!busy.has(sessionID)) {
-        if (trimmed.startsWith("/")) return
+      if (!busy.has(sid)) {
+        if (op.kind === "command") return
         text.text = body
         return
       }
 
-      const parts = output.parts.flatMap((part): InputPart[] => {
-        switch (part.type) {
-          case "text":
-            if (part.id !== text.id) return [{ ...part }]
-            return body ? [{ ...part, text: body }] : []
-          case "file":
-          case "agent":
-          case "subtask":
-            return [{ ...part }]
-          default:
-            console.warn("QueuePlugin skipped unexpected part", part.type)
-            return []
-        }
-      })
-
-      const info = { agent: output.message.agent, model: { ...output.message.model } }
-      const command = parseCommand(body)
-      const item = command
-        ? { info, text: trimmed, files, ...command }
-        : { info, text: label(body, files.length), parts }
+      const meta = input as Meta
+      const info = { agent: output.message.agent, model: { ...output.message.model }, variant: meta.variant, controls: meta.controls, fast: meta.fast }
+      const prior = await latest(sid)
+      if (prior) Object.assign(output.message, opts(prior))
+      else console.warn("QueuePlugin could not neutralize queued placeholder metadata because the session has no previous message context")
+      const inputParts = () =>
+        output.parts.flatMap((part): InputPart[] => {
+          if (part.type === "text") return part.id === text.id ? (body ? [{ ...part, text: body }] : []) : [{ ...part }]
+          if (part.type === "file" || part.type === "agent" || part.type === "subtask") return [{ ...part }]
+          console.warn("QueuePlugin skipped unexpected part", part.type)
+          return []
+        })
+      const item: Item = op.kind === "command" ? { ...op, info, files: parts } : { ...op, info, parts: inputParts() }
 
-      enqueue(sessionID, item)
+      queue.set(sid, [...(queue.get(sid) ?? []), item])
       hide(output.message.id, text)
       await toast(`Queued: ${item.text}`, "info")
     },

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-queue",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "description": "Queue OpenCode prompts and slash commands until the agent is idle",
   "main": "./index.ts",