refactor

Author: spoons-and-mirrors

packages/opencode/src/cli/cmd/tui/component/prompt/autocomplete.tsx

@@ -187,26 +187,9 @@ export function Autocomplete(props: {
     const results: AutocompleteOption[] = []
     const s = session()
 
-    // Plugin commands
-    for (const pluginCmd of sync.data.pluginCommand) {
-      if (pluginCmd.sessionOnly && !s) continue
-      results.push({
-        display: "/" + pluginCmd.name,
-        aliases: pluginCmd.aliases?.map((a) => "/" + a),
-        description: pluginCmd.description,
-        onSelect: async () => {
-          await sdk.client.pluginCommand.execute({
-            path: { name: pluginCmd.name },
-            body: { sessionID: props.sessionID },
-          })
-          // Clear the input
-          const cursor = props.input().logicalCursor
-          props.input().deleteRange(0, 0, cursor.row, cursor.col)
-        },
-      })
-    }
-
     for (const command of sync.data.command) {
+      if (command.sessionOnly && !s) continue
+
       results.push({
         display: "/" + command.name,
         description: command.description,

packages/opencode/src/cli/cmd/tui/context/sync.tsx

@@ -28,12 +28,6 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       provider: Provider[]
       agent: Agent[]
       command: Command[]
-      pluginCommand: Array<{
-        name: string
-        description: string
-        aliases?: string[]
-        sessionOnly?: boolean
-      }>
       permission: {
         [sessionID: string]: Permission[]
       }
@@ -62,8 +56,8 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
       agent: [],
       permission: {},
       command: [],
-      pluginCommand: [],
       provider: [],
+
       session: [],
       session_diff: {},
       todo: {},
@@ -244,8 +238,8 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
               ),
             ),
             sdk.client.command.list().then((x) => setStore("command", x.data ?? [])),
-            sdk.client.pluginCommand.list().then((x) => setStore("pluginCommand", x.data ?? [])),
             sdk.client.lsp.status().then((x) => setStore("lsp", x.data!)),
+
             sdk.client.mcp.status().then((x) => setStore("mcp", x.data!)),
             sdk.client.formatter.status().then((x) => setStore("formatter", x.data!)),
           ]).then(() => {

packages/opencode/src/command/index.ts

@@ -4,6 +4,7 @@ import { Instance } from "../project/instance"
 import PROMPT_INITIALIZE from "./template/initialize.txt"
 import { Bus } from "../bus"
 import { Identifier } from "../id/id"
+import { Plugin } from "../plugin"
 
 export namespace Command {
   export const Default = {
@@ -30,6 +31,7 @@ export namespace Command {
       model: z.string().optional(),
       template: z.string(),
       subtask: z.boolean().optional(),
+      sessionOnly: z.boolean().optional(),
     })
     .meta({
       ref: "Command",
@@ -60,6 +62,21 @@ export namespace Command {
       }
     }
 
+    const plugins = await Plugin.list()
+    for (const plugin of plugins) {
+      const commands = plugin["plugin.command"]
+      if (!commands) continue
+      for (const [name, cmd] of Object.entries(commands)) {
+        if (result[name]) continue
+        result[name] = {
+          name,
+          description: cmd.description,
+          template: "",
+          sessionOnly: cmd.sessionOnly,
+        }
+      }
+    }
+
     return result
   })
 

packages/opencode/src/plugin/index.ts

@@ -73,6 +73,10 @@ export namespace Plugin {
     return state().then((x) => x.hooks)
   }
 
+  export async function client() {
+    return state().then((x) => x.input.client)
+  }
+
   export async function init() {
     const hooks = await state().then((x) => x.hooks)
     const config = await Config.get()

packages/opencode/src/server/server.ts

@@ -1108,103 +1108,9 @@ export namespace Server {
           return c.json(commands)
         },
       )
-      .get(
-        "/plugin/command",
-        describeRoute({
-          description: "List all plugin commands",
-          operationId: "pluginCommand.list",
-          responses: {
-            200: {
-              description: "List of plugin commands",
-              content: {
-                "application/json": {
-                  schema: resolver(
-                    z
-                      .array(
-                        z.object({
-                          name: z.string(),
-                          description: z.string(),
-                          aliases: z.array(z.string()).optional(),
-                          sessionOnly: z.boolean().optional(),
-                        }),
-                      )
-                      .meta({ ref: "PluginCommand" }),
-                  ),
-                },
-              },
-            },
-          },
-        }),
-        async (c) => {
-          const plugins = await Plugin.list()
-          const commands = []
-          for (const plugin of plugins) {
-            const pluginCommands = plugin["plugin.command"]
-            if (!pluginCommands) continue
-            for (const [name, def] of Object.entries(pluginCommands)) {
-              commands.push({
-                name,
-                description: def.description,
-                aliases: def.aliases,
-                sessionOnly: def.sessionOnly,
-              })
-            }
-          }
-          return c.json(commands)
-        },
-      )
-      .post(
-        "/plugin/command/:name/execute",
-        describeRoute({
-          description: "Execute a plugin command",
-          operationId: "pluginCommand.execute",
-          responses: {
-            200: {
-              description: "Command executed",
-              content: {
-                "application/json": {
-                  schema: resolver(z.boolean()),
-                },
-              },
-            },
-            ...errors(400, 404),
-          },
-        }),
-        validator(
-          "param",
-          z.object({
-            name: z.string().meta({ description: "Plugin command name" }),
-          }),
-        ),
-        validator(
-          "json",
-          z.object({
-            sessionID: z.string().optional().meta({ description: "Session ID" }),
-          }),
-        ),
-        async (c) => {
-          const { name } = c.req.valid("param")
-          const { sessionID } = c.req.valid("json")
-
-          const plugins = await Plugin.list()
-          for (const plugin of plugins) {
-            const command = plugin["plugin.command"]?.[name]
-            if (!command) continue
-
-            const client = createOpencodeClient({
-              baseUrl: "http://localhost:4096",
-              fetch: async (...args) => Server.App().fetch(...args),
-            })
-
-            await command.execute({ sessionID, client })
-            return c.json(true)
-          }
-
-          return c.json({ error: "Command not found" }, 404)
-        },
-      )
       .get(
         "/config/providers",
+
         describeRoute({
           description: "List all providers",
           operationId: "config.providers",

packages/opencode/src/session/prompt.ts

@@ -1631,7 +1631,42 @@ export namespace SessionPrompt {
   export async function command(input: CommandInput) {
     log.info("command", input)
     const command = await Command.get(input.command)
-    const agentName = command.agent ?? input.agent ?? "build"
+    const agentName = command?.agent ?? input.agent ?? "build"
+
+    const plugins = await Plugin.list()
+    for (const plugin of plugins) {
+      const pluginCommands = plugin["plugin.command"]
+      const pluginCommand = pluginCommands?.[input.command]
+      if (!pluginCommand) continue
+
+      const client = await Plugin.client()
+      await pluginCommand.execute({ sessionID: input.sessionID, client })
+      const last = await Session.messages({ sessionID: input.sessionID, limit: 1 })
+      const message = last.at(0)
+      if (message) return message
+      return await SessionPrompt.prompt({
+        sessionID: input.sessionID,
+        agent: agentName,
+        parts: [
+          {
+            type: "text",
+            text: "",
+          },
+        ],
+      })
+    }
+
+    if (!command)
+      return await SessionPrompt.prompt({
+        sessionID: input.sessionID,
+        agent: agentName,
+        parts: [
+          {
+            type: "text",
+            text: "",
+          },
+        ],
+      })
 
     const raw = input.arguments.match(argsRegex) ?? []
     const args = raw.map((arg) => arg.replace(quoteTrimRegex, ""))

packages/sdk/js/src/gen/types.gen.ts

@@ -1215,6 +1215,7 @@ export type Command = {
   model?: string
   template: string
   subtask?: boolean
+  sessionOnly?: boolean
 }
 
 export type Model = {

packages/web/src/content/docs/plugins.mdx

@@ -166,11 +166,11 @@ export const CommandsPlugin: Plugin = async (ctx) => {
 }
 ```
 
-The `plugin.command` hook lets you define commands that appear in TUI autocomplete. Each command has:
+The `plugin.command` hook lets you define commands that appear in command listings. Each command has:
 
 - `description`: Brief description shown in autocomplete
 - `aliases`: Alternative names for the command (optional)
 - `sessionOnly`: Whether command requires an active session (optional)
 - `execute`: Function that runs when the command is invoked
 
-Commands are invoked by typing `/command-name` in the TUI.
+Commands are invoked by typing `/command-name` in the TUI.