@elizaos/plugin-commands 1.0.0

package/dist/cjs/index.cjs

@@ -0,0 +1,1077 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  unregisterCommand: () => unregisterCommand,
+  startsWithCommand: () => startsWithCommand,
+  resetCommands: () => resetCommands,
+  registerCommands: () => registerCommands,
+  registerCommand: () => registerCommand,
+  parseCommand: () => parseCommand,
+  normalizeCommandBody: () => normalizeCommandBody,
+  isElevated: () => isElevated,
+  isCommandOnly: () => isCommandOnly,
+  isAuthorized: () => isAuthorized,
+  hasCommand: () => hasCommand,
+  getEnabledCommands: () => getEnabledCommands,
+  getCommandsByCategory: () => getCommandsByCategory,
+  getCommands: () => getCommands,
+  formatCommandResult: () => formatCommandResult,
+  findCommandByKey: () => findCommandByKey,
+  findCommandByAlias: () => findCommandByAlias,
+  extractCommand: () => extractCommand,
+  detectCommand: () => detectCommand,
+  default: () => src_default,
+  commandsPlugin: () => commandsPlugin,
+  commandRegistryProvider: () => commandRegistryProvider
+});
+module.exports = __toCommonJS(exports_src);
+var import_core = require("@elizaos/core");
+
+// src/registry.ts
+var DEFAULT_COMMANDS = [
+  {
+    key: "help",
+    nativeName: "help",
+    description: "Show available commands",
+    textAliases: ["/help", "/h", "/?"],
+    scope: "both",
+    category: "status",
+    acceptsArgs: false
+  },
+  {
+    key: "commands",
+    nativeName: "commands",
+    description: "List all commands",
+    textAliases: ["/commands", "/cmds"],
+    scope: "both",
+    category: "status",
+    acceptsArgs: false
+  },
+  {
+    key: "status",
+    nativeName: "status",
+    description: "Show current session status",
+    textAliases: ["/status", "/s"],
+    scope: "both",
+    category: "status",
+    acceptsArgs: false
+  },
+  {
+    key: "context",
+    nativeName: "context",
+    description: "Show current context information",
+    textAliases: ["/context", "/ctx"],
+    scope: "both",
+    category: "status",
+    acceptsArgs: true,
+    args: [{ name: "mode", description: "Output mode (list, detail, json)" }]
+  },
+  {
+    key: "whoami",
+    nativeName: "whoami",
+    description: "Show your identity information",
+    textAliases: ["/whoami", "/who"],
+    scope: "both",
+    category: "status",
+    acceptsArgs: false
+  },
+  {
+    key: "stop",
+    nativeName: "stop",
+    description: "Stop current operation",
+    textAliases: ["/stop", "/abort", "/cancel"],
+    scope: "both",
+    category: "session",
+    acceptsArgs: false
+  },
+  {
+    key: "restart",
+    nativeName: "restart",
+    description: "Restart the session",
+    textAliases: ["/restart"],
+    scope: "both",
+    category: "session",
+    acceptsArgs: false,
+    requiresAuth: true
+  },
+  {
+    key: "reset",
+    nativeName: "reset",
+    description: "Reset session state",
+    textAliases: ["/reset"],
+    scope: "both",
+    category: "session",
+    acceptsArgs: false,
+    requiresAuth: true
+  },
+  {
+    key: "new",
+    nativeName: "new",
+    description: "Start a new conversation",
+    textAliases: ["/new"],
+    scope: "both",
+    category: "session",
+    acceptsArgs: false
+  },
+  {
+    key: "compact",
+    nativeName: "compact",
+    description: "Compact conversation history",
+    textAliases: ["/compact"],
+    scope: "both",
+    category: "session",
+    acceptsArgs: true,
+    args: [
+      { name: "instructions", description: "Optional compaction instructions" }
+    ]
+  },
+  {
+    key: "think",
+    nativeName: "think",
+    description: "Set thinking level",
+    textAliases: ["/think", "/thinking", "/t"],
+    scope: "both",
+    category: "options",
+    acceptsArgs: true,
+    args: [
+      { name: "level", description: "off, minimal, low, medium, high, xhigh" }
+    ]
+  },
+  {
+    key: "verbose",
+    nativeName: "verbose",
+    description: "Set verbose output level",
+    textAliases: ["/verbose", "/v"],
+    scope: "both",
+    category: "options",
+    acceptsArgs: true,
+    args: [{ name: "level", description: "off, on, full" }]
+  },
+  {
+    key: "reasoning",
+    nativeName: "reasoning",
+    description: "Set reasoning visibility",
+    textAliases: ["/reasoning", "/reason"],
+    scope: "both",
+    category: "options",
+    acceptsArgs: true,
+    args: [{ name: "level", description: "off, on, stream" }]
+  },
+  {
+    key: "elevated",
+    nativeName: "elevated",
+    description: "Set elevated permission mode",
+    textAliases: ["/elevated", "/elev"],
+    scope: "both",
+    category: "options",
+    acceptsArgs: true,
+    args: [{ name: "level", description: "off, on, ask, full" }],
+    requiresAuth: true
+  },
+  {
+    key: "model",
+    nativeName: "model",
+    description: "Set or show current model",
+    textAliases: ["/model", "/m"],
+    scope: "both",
+    category: "options",
+    acceptsArgs: true,
+    args: [{ name: "model", description: "provider/model or alias" }]
+  },
+  {
+    key: "models",
+    nativeName: "models",
+    description: "List available models",
+    textAliases: ["/models"],
+    scope: "both",
+    category: "options",
+    acceptsArgs: false
+  },
+  {
+    key: "usage",
+    nativeName: "usage",
+    description: "Show token usage",
+    textAliases: ["/usage"],
+    scope: "both",
+    category: "options",
+    acceptsArgs: false
+  },
+  {
+    key: "queue",
+    nativeName: "queue",
+    description: "Set queue mode",
+    textAliases: ["/queue", "/q"],
+    scope: "both",
+    category: "options",
+    acceptsArgs: true,
+    args: [
+      {
+        name: "mode",
+        description: "steer, followup, collect, interrupt, or options"
+      }
+    ]
+  },
+  {
+    key: "allowlist",
+    nativeName: "allowlist",
+    description: "Manage sender allowlist",
+    textAliases: ["/allowlist", "/allow"],
+    scope: "both",
+    category: "management",
+    acceptsArgs: true,
+    args: [
+      { name: "action", description: "list, add, remove" },
+      { name: "value", description: "sender to add/remove" }
+    ],
+    requiresAuth: true
+  },
+  {
+    key: "approve",
+    nativeName: "approve",
+    description: "Approve or deny a pending action",
+    textAliases: ["/approve"],
+    scope: "both",
+    category: "management",
+    acceptsArgs: true,
+    args: [
+      { name: "id", description: "Approval ID", required: true },
+      { name: "action", description: "allow-once, allow-always, deny" }
+    ],
+    requiresAuth: true
+  },
+  {
+    key: "subagents",
+    nativeName: "subagents",
+    description: "Manage subagents",
+    textAliases: ["/subagents", "/sub"],
+    scope: "both",
+    category: "management",
+    acceptsArgs: true,
+    args: [{ name: "action", description: "list, stop, log, info, send" }],
+    requiresAuth: true
+  },
+  {
+    key: "config",
+    nativeName: "config",
+    description: "View or set configuration",
+    textAliases: ["/config", "/cfg"],
+    scope: "both",
+    category: "management",
+    acceptsArgs: true,
+    args: [
+      { name: "key", description: "Configuration key" },
+      { name: "value", description: "Value to set" }
+    ],
+    requiresAuth: true,
+    enabled: false
+  },
+  {
+    key: "debug",
+    nativeName: "debug",
+    description: "Debug information",
+    textAliases: ["/debug"],
+    scope: "both",
+    category: "management",
+    acceptsArgs: true,
+    requiresAuth: true,
+    enabled: false
+  },
+  {
+    key: "tts",
+    nativeName: "tts",
+    description: "Text-to-speech settings",
+    textAliases: ["/tts", "/voice"],
+    scope: "both",
+    category: "media",
+    acceptsArgs: true,
+    args: [
+      {
+        name: "action",
+        description: "on, off, status, provider, limit, audio"
+      }
+    ]
+  },
+  {
+    key: "bash",
+    nativeName: "bash",
+    description: "Execute shell command",
+    textAliases: ["/bash", "/sh", "/!"],
+    scope: "text",
+    category: "tools",
+    acceptsArgs: true,
+    args: [
+      {
+        name: "command",
+        description: "Shell command to execute",
+        captureRemaining: true
+      }
+    ],
+    requiresAuth: true,
+    requiresElevated: true
+  }
+];
+var commands = [...DEFAULT_COMMANDS];
+var aliasMap = null;
+function getCommands() {
+  return [...commands];
+}
+function getEnabledCommands() {
+  return commands.filter((cmd) => cmd.enabled !== false);
+}
+function getCommandsByCategory(category) {
+  return commands.filter((cmd) => cmd.category === category && cmd.enabled !== false);
+}
+function registerCommand(command) {
+  commands = commands.filter((c) => c.key !== command.key);
+  commands.push(command);
+  aliasMap = null;
+}
+function registerCommands(newCommands) {
+  for (const command of newCommands) {
+    registerCommand(command);
+  }
+}
+function unregisterCommand(key) {
+  commands = commands.filter((c) => c.key !== key);
+  aliasMap = null;
+}
+function resetCommands() {
+  commands = [...DEFAULT_COMMANDS];
+  aliasMap = null;
+}
+function getAliasMap() {
+  if (aliasMap)
+    return aliasMap;
+  aliasMap = new Map;
+  for (const command of commands) {
+    if (command.enabled === false)
+      continue;
+    for (const alias of command.textAliases) {
+      const normalized = alias.toLowerCase().trim();
+      if (!aliasMap.has(normalized)) {
+        aliasMap.set(normalized, command);
+      }
+    }
+  }
+  return aliasMap;
+}
+function findCommandByAlias(alias) {
+  const map = getAliasMap();
+  return map.get(alias.toLowerCase().trim());
+}
+function findCommandByKey(key) {
+  return commands.find((c) => c.key === key);
+}
+function startsWithCommand(text) {
+  const map = getAliasMap();
+  const normalized = text.toLowerCase().trim();
+  for (const [alias, command] of map) {
+    if (normalized === alias) {
+      return command;
+    }
+    if (normalized.startsWith(alias + " ") || normalized.startsWith(alias + ":")) {
+      return command;
+    }
+  }
+  return;
+}
+
+// src/parser.ts
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function hasCommand(text) {
+  if (!text)
+    return false;
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/") && !trimmed.startsWith("!"))
+    return false;
+  return Boolean(startsWithCommand(trimmed));
+}
+function detectCommand(text) {
+  if (!text) {
+    return { isCommand: false };
+  }
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("/") && !trimmed.startsWith("!")) {
+    return { isCommand: false };
+  }
+  const command = startsWithCommand(trimmed);
+  if (!command) {
+    return { isCommand: false };
+  }
+  const parsed = parseCommand(trimmed, command);
+  if (!parsed) {
+    return { isCommand: false };
+  }
+  return { isCommand: true, command: parsed };
+}
+function parseCommand(text, definition) {
+  const trimmed = text.trim();
+  let matchedAlias = null;
+  for (const alias of definition.textAliases) {
+    const normalized = alias.toLowerCase();
+    if (trimmed.toLowerCase() === normalized) {
+      matchedAlias = alias;
+      break;
+    }
+    if (trimmed.toLowerCase().startsWith(normalized + " ") || trimmed.toLowerCase().startsWith(normalized + ":")) {
+      matchedAlias = alias;
+      break;
+    }
+  }
+  if (!matchedAlias) {
+    return null;
+  }
+  let rawArgs = trimmed.slice(matchedAlias.length).trim();
+  if (rawArgs.startsWith(":")) {
+    rawArgs = rawArgs.slice(1).trim();
+  }
+  const args = parseArgs(rawArgs, definition);
+  return {
+    key: definition.key,
+    canonical: definition.textAliases[0] ?? `/${definition.key}`,
+    args,
+    rawArgs: rawArgs || undefined
+  };
+}
+function parseArgs(rawArgs, definition) {
+  if (!rawArgs || !definition.acceptsArgs) {
+    return [];
+  }
+  const parsing = definition.argsParsing ?? "positional";
+  if (parsing === "none") {
+    return rawArgs ? [rawArgs] : [];
+  }
+  const args = [];
+  const argDefs = definition.args ?? [];
+  const tokens = tokenize(rawArgs);
+  for (let i = 0;i < tokens.length; i++) {
+    const argDef = argDefs[i];
+    if (argDef?.captureRemaining) {
+      args.push(tokens.slice(i).join(" "));
+      break;
+    }
+    args.push(tokens[i]);
+  }
+  return args;
+}
+function tokenize(input) {
+  const tokens = [];
+  let current = "";
+  let inQuote = false;
+  let quoteChar = "";
+  for (let i = 0;i < input.length; i++) {
+    const char = input[i];
+    if (inQuote) {
+      if (char === quoteChar) {
+        inQuote = false;
+        if (current) {
+          tokens.push(current);
+          current = "";
+        }
+      } else {
+        current += char;
+      }
+    } else if (char === '"' || char === "'") {
+      inQuote = true;
+      quoteChar = char;
+    } else if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function normalizeCommandBody(text, botMention) {
+  let normalized = text.trim();
+  if (botMention) {
+    const mentionPattern = new RegExp(`^@${escapeRegExp(botMention)}\\s*`, "i");
+    normalized = normalized.replace(mentionPattern, "");
+  }
+  normalized = normalized.replace(/^(\/\w+):\s*/, "$1 ");
+  return normalized.trim();
+}
+function isCommandOnly(text) {
+  const detection = detectCommand(text);
+  if (!detection.isCommand || !detection.command) {
+    return false;
+  }
+  if (!detection.command.rawArgs) {
+    return true;
+  }
+  return detection.command.rawArgs.trim().length === 0;
+}
+function extractCommand(text) {
+  const detection = detectCommand(text);
+  if (!detection.isCommand || !detection.command) {
+    return null;
+  }
+  const { command } = detection;
+  if (!command.rawArgs) {
+    return { command, remainingText: "" };
+  }
+  return { command, remainingText: command.rawArgs };
+}
+
+// src/actions/commands-list.ts
+var commandsListAction = {
+  name: "COMMANDS_LIST",
+  description: "List all available commands with their aliases",
+  similes: ["/commands", "/cmds", "list all commands"],
+  async validate(runtime, message) {
+    const text = message.content?.text ?? "";
+    const detection = detectCommand(text);
+    return detection.isCommand && detection.command?.key === "commands";
+  },
+  async handler(runtime, message, state, options, callback) {
+    const commands2 = getEnabledCommands();
+    const lines = [`**Commands (${commands2.length}):**
+`];
+    for (const cmd of commands2) {
+      const aliases = cmd.textAliases.join(", ");
+      const authNote = cmd.requiresAuth ? " [auth]" : "";
+      const elevatedNote = cmd.requiresElevated ? " [elevated]" : "";
+      lines.push(`• **${cmd.key}**: ${aliases}${authNote}${elevatedNote}`);
+    }
+    const replyText = lines.join(`
+`);
+    await callback?.({ text: replyText });
+    return {
+      success: true,
+      text: replyText,
+      data: { commandCount: commands2.length }
+    };
+  },
+  examples: [
+    [
+      { user: "user", content: { text: "/commands" } },
+      {
+        user: "assistant",
+        content: {
+          text: `**Commands (15):**
+
+• **help**: /help, /h, /?
+• **status**: /status, /s...`
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/help.ts
+function formatCommandList(commands2) {
+  const lines = [`**Available Commands:**
+`];
+  const categories = [
+    { key: "status", name: "Status" },
+    { key: "session", name: "Session" },
+    { key: "options", name: "Options" },
+    { key: "management", name: "Management" },
+    { key: "media", name: "Media" },
+    { key: "tools", name: "Tools" }
+  ];
+  for (const cat of categories) {
+    const catCommands = commands2.filter((c) => c.category === cat.key);
+    if (catCommands.length === 0)
+      continue;
+    lines.push(`
+**${cat.name}:**`);
+    for (const cmd of catCommands) {
+      const aliases = cmd.textAliases.slice(0, 2).join(", ");
+      lines.push(`• ${aliases} - ${cmd.description}`);
+    }
+  }
+  const uncategorized = commands2.filter((c) => !c.category);
+  if (uncategorized.length > 0) {
+    lines.push(`
+**Other:**`);
+    for (const cmd of uncategorized) {
+      const aliases = cmd.textAliases.slice(0, 2).join(", ");
+      lines.push(`• ${aliases} - ${cmd.description}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+var helpAction = {
+  name: "HELP_COMMAND",
+  description: "Show available commands and their descriptions",
+  similes: ["/help", "/h", "/?", "help", "show help", "list commands"],
+  async validate(runtime, message) {
+    const text = message.content?.text ?? "";
+    const detection = detectCommand(text);
+    return detection.isCommand && detection.command?.key === "help";
+  },
+  async handler(runtime, message, state, options, callback) {
+    const commands2 = getEnabledCommands();
+    const helpText = formatCommandList(commands2);
+    await callback?.({ text: helpText });
+    return {
+      success: true,
+      text: helpText,
+      data: { commandCount: commands2.length }
+    };
+  },
+  examples: [
+    [
+      { user: "user", content: { text: "/help" } },
+      {
+        user: "assistant",
+        content: {
+          text: `**Available Commands:**
+
+**Status:**
+• /help - Show available commands...`
+        }
+      }
+    ],
+    [
+      { user: "user", content: { text: "/?" } },
+      {
+        user: "assistant",
+        content: {
+          text: `**Available Commands:**
+
+**Status:**
+• /help - Show available commands...`
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/models.ts
+var modelsAction = {
+  name: "MODELS_COMMAND",
+  description: "List available AI models and providers",
+  similes: ["/models", "list models", "show models", "available models"],
+  async validate(runtime, message) {
+    const text = message.content?.text ?? "";
+    const detection = detectCommand(text);
+    return detection.isCommand && detection.command?.key === "models";
+  },
+  async handler(runtime, message, state, options, callback) {
+    const lines = [`**Available Models:**
+`];
+    const providers = [
+      {
+        name: "Anthropic",
+        models: [
+          "claude-3-opus",
+          "claude-3-sonnet",
+          "claude-3-haiku",
+          "claude-3.5-sonnet"
+        ]
+      },
+      {
+        name: "OpenAI",
+        models: [
+          "gpt-4o",
+          "gpt-4o-mini",
+          "gpt-4-turbo",
+          "gpt-4",
+          "gpt-3.5-turbo"
+        ]
+      },
+      {
+        name: "Google",
+        models: ["gemini-pro", "gemini-pro-vision", "gemini-ultra"]
+      }
+    ];
+    for (const provider of providers) {
+      lines.push(`
+**${provider.name}:**`);
+      for (const model of provider.models) {
+        lines.push(`• ${provider.name.toLowerCase()}/${model}`);
+      }
+    }
+    lines.push(`
+
+_Use /model <provider/model> to switch models._`);
+    const replyText = lines.join(`
+`);
+    await callback?.({ text: replyText });
+    return {
+      success: true,
+      text: replyText,
+      data: { providers }
+    };
+  },
+  examples: [
+    [
+      { user: "user", content: { text: "/models" } },
+      {
+        user: "assistant",
+        content: {
+          text: `**Available Models:**
+
+**Anthropic:**
+• anthropic/claude-3-opus
+• anthropic/claude-3-sonnet...`
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/status.ts
+async function buildStatusReport(runtime, roomId) {
+  const lines = [`**Session Status:**
+`];
+  lines.push(`**Agent:** ${runtime.agentId}`);
+  lines.push(`**Room:** ${roomId}`);
+  try {
+    const directiveService = runtime.getService("directive-parser");
+    if (directiveService) {
+      const state = directiveService.getSessionState?.(roomId);
+      if (state) {
+        lines.push(`
+**Directives:**`);
+        lines.push(`• Thinking: ${state.thinking}`);
+        lines.push(`• Verbose: ${state.verbose}`);
+        lines.push(`• Reasoning: ${state.reasoning}`);
+        lines.push(`• Elevated: ${state.elevated}`);
+        if (state.model?.provider || state.model?.model) {
+          const modelStr = state.model.provider ? `${state.model.provider}/${state.model.model}` : state.model.model;
+          lines.push(`• Model: ${modelStr}`);
+        }
+      }
+    }
+  } catch {}
+  return lines.join(`
+`);
+}
+var statusAction = {
+  name: "STATUS_COMMAND",
+  description: "Show current session status, model, and settings",
+  similes: ["/status", "/s", "status", "show status", "what's my status"],
+  async validate(runtime, message) {
+    const text = message.content?.text ?? "";
+    const detection = detectCommand(text);
+    return detection.isCommand && detection.command?.key === "status";
+  },
+  async handler(runtime, message, state, options, callback) {
+    const statusText = await buildStatusReport(runtime, message.roomId);
+    await callback?.({ text: statusText });
+    return {
+      success: true,
+      text: statusText
+    };
+  },
+  examples: [
+    [
+      { user: "user", content: { text: "/status" } },
+      {
+        user: "assistant",
+        content: {
+          text: `**Session Status:**
+
+**Agent:** agent-123
+**Room:** room-456
+
+**Directives:**
+• Thinking: low...`
+        }
+      }
+    ]
+  ]
+};
+
+// src/actions/stop.ts
+var stopAction = {
+  name: "STOP_COMMAND",
+  description: "Stop current operation or abort running tasks",
+  similes: ["/stop", "/abort", "/cancel", "stop", "abort", "cancel"],
+  async validate(runtime, message) {
+    const text = message.content?.text ?? "";
+    const detection = detectCommand(text);
+    return detection.isCommand && ["stop", "abort", "cancel"].includes(detection.command?.key ?? "");
+  },
+  async handler(runtime, message, state, options, callback) {
+    try {
+      await runtime.emitEvent?.("ABORT_REQUESTED", {
+        roomId: message.roomId,
+        userId: message.userId,
+        requestedAt: Date.now()
+      });
+    } catch {}
+    const replyText = "✓ Stop requested. Current operations will be cancelled.";
+    await callback?.({ text: replyText });
+    return {
+      success: true,
+      text: replyText
+    };
+  },
+  examples: [
+    [
+      { user: "user", content: { text: "/stop" } },
+      {
+        user: "assistant",
+        content: {
+          text: "✓ Stop requested. Current operations will be cancelled."
+        }
+      }
+    ],
+    [
+      { user: "user", content: { text: "/abort" } },
+      {
+        user: "assistant",
+        content: {
+          text: "✓ Stop requested. Current operations will be cancelled."
+        }
+      }
+    ]
+  ]
+};
+
+// src/index.ts
+var commandRegistryProvider = {
+  name: "COMMAND_REGISTRY",
+  description: "Available chat commands and their descriptions",
+  dynamic: true,
+  async get(runtime, message, _state) {
+    const commands2 = getEnabledCommands();
+    const commandList = commands2.map((cmd) => {
+      const auth = cmd.requiresAuth ? " (requires auth)" : "";
+      return `- ${cmd.textAliases[0]}: ${cmd.description}${auth}`;
+    });
+    return {
+      text: `Available commands:
+${commandList.join(`
+`)}`,
+      values: {
+        commandCount: commands2.length,
+        hasElevatedCommands: commands2.some((c) => c.requiresElevated)
+      },
+      data: { commands: commands2 }
+    };
+  }
+};
+function formatCommandResult(result) {
+  if (result.error) {
+    return `❌ Error: ${result.error}`;
+  }
+  return result.reply ?? "✓ Command executed";
+}
+function isAuthorized(context, command) {
+  if (!command.requiresAuth) {
+    return true;
+  }
+  return context.isAuthorized;
+}
+function isElevated(context, command) {
+  if (!command.requiresElevated) {
+    return true;
+  }
+  return context.isElevated;
+}
+var commandsPlugin = {
+  name: "commands",
+  description: "Chat command system with /help, /status, /reset, etc.",
+  providers: [commandRegistryProvider],
+  actions: [
+    helpAction,
+    statusAction,
+    stopAction,
+    modelsAction,
+    commandsListAction
+  ],
+  config: {
+    COMMANDS_ENABLED: "true",
+    COMMANDS_CONFIG_ENABLED: "false",
+    COMMANDS_DEBUG_ENABLED: "false",
+    COMMANDS_BASH_ENABLED: "false",
+    COMMANDS_RESTART_ENABLED: "true"
+  },
+  tests: [
+    {
+      name: "command-detection",
+      tests: [
+        {
+          name: "Detect command prefix",
+          fn: async (_runtime) => {
+            if (!hasCommand("/help")) {
+              throw new Error("Should detect /help command");
+            }
+            if (!hasCommand("/status test")) {
+              throw new Error("Should detect /status with args");
+            }
+            if (hasCommand("hello world")) {
+              throw new Error("Should not detect plain text as command");
+            }
+            import_core.logger.success("Command prefix detection works correctly");
+          }
+        },
+        {
+          name: "Parse command with args",
+          fn: async (_runtime) => {
+            const detection = detectCommand("/think:high");
+            if (!detection.isCommand) {
+              throw new Error("Should detect think command");
+            }
+            if (detection.command?.key !== "think") {
+              throw new Error(`Expected key 'think', got '${detection.command?.key}'`);
+            }
+            if (detection.command?.args[0] !== "high") {
+              throw new Error(`Expected arg 'high', got '${detection.command?.args[0]}'`);
+            }
+            import_core.logger.success("Command argument parsing works correctly");
+          }
+        },
+        {
+          name: "Normalize command body",
+          fn: async (_runtime) => {
+            const normalized1 = normalizeCommandBody("/status: test");
+            if (normalized1 !== "/status test") {
+              throw new Error(`Expected '/status test', got '${normalized1}'`);
+            }
+            const normalized2 = normalizeCommandBody("@bot /help", "bot");
+            if (normalized2 !== "/help") {
+              throw new Error(`Expected '/help', got '${normalized2}'`);
+            }
+            import_core.logger.success("Command normalization works correctly");
+          }
+        },
+        {
+          name: "Find command by alias",
+          fn: async (_runtime) => {
+            const cmd = findCommandByAlias("/h");
+            if (!cmd) {
+              throw new Error("Should find help command by /h alias");
+            }
+            if (cmd.key !== "help") {
+              throw new Error(`Expected key 'help', got '${cmd.key}'`);
+            }
+            import_core.logger.success("Command alias lookup works correctly");
+          }
+        },
+        {
+          name: "Find command by key",
+          fn: async (_runtime) => {
+            const cmd = findCommandByKey("status");
+            if (!cmd) {
+              throw new Error("Should find status command by key");
+            }
+            if (cmd.key !== "status") {
+              throw new Error(`Expected key 'status', got '${cmd.key}'`);
+            }
+            import_core.logger.success("Command key lookup works correctly");
+          }
+        }
+      ]
+    },
+    {
+      name: "command-registry",
+      tests: [
+        {
+          name: "Get enabled commands",
+          fn: async (_runtime) => {
+            const commands2 = getEnabledCommands();
+            if (commands2.length === 0) {
+              throw new Error("Should have enabled commands");
+            }
+            const hasHelp = commands2.some((c) => c.key === "help");
+            const hasStatus = commands2.some((c) => c.key === "status");
+            if (!hasHelp || !hasStatus) {
+              throw new Error("Should have help and status commands");
+            }
+            import_core.logger.success("Command registry works correctly");
+          }
+        },
+        {
+          name: "Register custom command",
+          fn: async (_runtime) => {
+            const customCmd = {
+              key: "test-custom",
+              description: "Test custom command",
+              textAliases: ["/test-custom", "/tc"],
+              scope: "text"
+            };
+            registerCommand(customCmd);
+            const found = findCommandByKey("test-custom");
+            if (!found) {
+              throw new Error("Should find registered custom command");
+            }
+            unregisterCommand("test-custom");
+            const notFound = findCommandByKey("test-custom");
+            if (notFound) {
+              throw new Error("Should not find unregistered command");
+            }
+            import_core.logger.success("Custom command registration works correctly");
+          }
+        },
+        {
+          name: "Get commands by category",
+          fn: async (_runtime) => {
+            const statusCommands = getCommandsByCategory("status");
+            if (statusCommands.length === 0) {
+              throw new Error("Should have status category commands");
+            }
+            const allStatus = statusCommands.every((c) => c.category === "status");
+            if (!allStatus) {
+              throw new Error("All returned commands should be in status category");
+            }
+            import_core.logger.success("Command categorization works correctly");
+          }
+        }
+      ]
+    }
+  ],
+  async init(config, runtime) {
+    import_core.logger.log("[plugin-commands] Initializing command system");
+    const configEnabled = config.COMMANDS_CONFIG_ENABLED === "true";
+    const debugEnabled = config.COMMANDS_DEBUG_ENABLED === "true";
+    const bashEnabled = config.COMMANDS_BASH_ENABLED === "true";
+    const configCmd = findCommandByKey("config");
+    if (configCmd) {
+      configCmd.enabled = configEnabled;
+    }
+    const debugCmd = findCommandByKey("debug");
+    if (debugCmd) {
+      debugCmd.enabled = debugEnabled;
+    }
+    const bashCmd = findCommandByKey("bash");
+    if (bashCmd) {
+      bashCmd.enabled = bashEnabled;
+    }
+    const enabledCount = getEnabledCommands().length;
+    import_core.logger.log(`[plugin-commands] ${enabledCount} commands enabled`);
+  }
+};
+var src_default = commandsPlugin;
+
+//# debugId=F42BC7360B07F25664756E2164756E21