@affectively/slash-commands 1.0.0

package/dist/index.js

@@ -0,0 +1,1006 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SlashCommandRegistry: () => SlashCommandRegistry,
+  createAPIExecutor: () => createAPIExecutor,
+  executeSlashCommand: () => executeSlashCommand,
+  extractCategory: () => extractCategory,
+  extractCommandName: () => extractCommandName,
+  extractParametersFromJsonSchema: () => extractParametersFromJsonSchema,
+  extractParametersFromZod: () => extractParametersFromZod,
+  formatCommand: () => formatCommand,
+  fuzzyMatch: () => fuzzyMatch,
+  generateAliases: () => generateAliases,
+  generateExamples: () => generateExamples,
+  generateHelpText: () => generateHelpText,
+  generateSlashCommand: () => generateSlashCommand,
+  generateSlashCommands: () => generateSlashCommands,
+  getAllSlashCommands: () => getAllSlashCommands,
+  getAutocompleteSuggestions: () => getAutocompleteSuggestions,
+  getPartialCommand: () => getPartialCommand,
+  getReplacementRange: () => getReplacementRange,
+  getSlashCommand: () => getSlashCommand,
+  getSuggestionsGroupedByCategory: () => getSuggestionsGroupedByCategory,
+  hasSlashCommand: () => hasSlashCommand,
+  isSlashCommand: () => isSlashCommand,
+  parseSlashCommand: () => parseSlashCommand,
+  shouldShowAutocomplete: () => shouldShowAutocomplete,
+  slashCommandRegistry: () => slashCommandRegistry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/generator.ts
+var import_zod = require("zod");
+function extractCategory(toolName) {
+  const parts = toolName.split("_");
+  if (parts.length > 1) {
+    return parts[0];
+  }
+  return toolName;
+}
+function extractParametersFromZod(schema) {
+  const parameters = [];
+  if (schema instanceof import_zod.z.ZodObject) {
+    const shape = schema.shape;
+    for (const [name, fieldSchema] of Object.entries(shape)) {
+      const param = extractSingleParameter(
+        name,
+        fieldSchema,
+        schema
+      );
+      if (param) {
+        parameters.push(param);
+      }
+    }
+  }
+  return parameters;
+}
+function extractSingleParameter(name, fieldSchema, _parentSchema) {
+  let innerSchema = fieldSchema;
+  let isOptional = false;
+  let defaultValue = void 0;
+  if (innerSchema instanceof import_zod.z.ZodOptional) {
+    isOptional = true;
+    innerSchema = innerSchema._def.innerType;
+  }
+  if (innerSchema instanceof import_zod.z.ZodNullable) {
+    isOptional = true;
+    innerSchema = innerSchema._def.innerType;
+  }
+  if (innerSchema instanceof import_zod.z.ZodDefault) {
+    defaultValue = innerSchema._def.defaultValue();
+    innerSchema = innerSchema._def.innerType;
+  }
+  const description = innerSchema._def.description || fieldSchema._def.description || "";
+  const typeInfo = getZodType(innerSchema);
+  return {
+    name,
+    type: typeInfo.type,
+    description,
+    required: !isOptional && defaultValue === void 0,
+    defaultValue,
+    enumValues: typeInfo.enumValues
+  };
+}
+function getZodType(schema) {
+  if (schema instanceof import_zod.z.ZodString) {
+    return { type: "string" };
+  }
+  if (schema instanceof import_zod.z.ZodNumber) {
+    return { type: "number" };
+  }
+  if (schema instanceof import_zod.z.ZodBoolean) {
+    return { type: "boolean" };
+  }
+  if (schema instanceof import_zod.z.ZodEnum) {
+    return {
+      type: "enum",
+      enumValues: schema._def.values
+    };
+  }
+  if (schema instanceof import_zod.z.ZodArray) {
+    return { type: "array" };
+  }
+  if (schema instanceof import_zod.z.ZodObject) {
+    return { type: "object" };
+  }
+  if (schema instanceof import_zod.z.ZodNativeEnum) {
+    const values = Object.values(schema._def.values).filter(
+      (v) => typeof v === "string"
+    );
+    return { type: "enum", enumValues: values };
+  }
+  return { type: "string" };
+}
+function generateHelpText(name, description, parameters) {
+  const lines = [];
+  lines.push(`/${name}`);
+  lines.push("");
+  lines.push(description);
+  if (parameters.length > 0) {
+    lines.push("");
+    lines.push("Parameters:");
+    for (const param of parameters) {
+      const required = param.required ? "(required)" : "(optional)";
+      const type = param.enumValues ? `[${param.enumValues.join("|")}]` : `<${param.type}>`;
+      const defaultStr = param.defaultValue !== void 0 ? ` (default: ${JSON.stringify(param.defaultValue)})` : "";
+      lines.push(`  ${param.name} ${type} ${required}${defaultStr}`);
+      if (param.description) {
+        lines.push(`    ${param.description}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function generateExamples(name, parameters) {
+  const examples = [];
+  examples.push(`/${name}`);
+  const stringParams = parameters.filter(
+    (p) => p.type === "string" && !p.enumValues
+  );
+  const enumParams = parameters.filter(
+    (p) => p.type === "enum" && p.enumValues
+  );
+  const numberParams = parameters.filter((p) => p.type === "number");
+  if (enumParams.length > 0) {
+    const param = enumParams[0];
+    const value = param.enumValues?.[0] || "value";
+    examples.push(`/${name} ${param.name}=${value}`);
+  }
+  if (stringParams.length > 0) {
+    const param = stringParams[0];
+    examples.push(`/${name} ${param.name}="example"`);
+  }
+  const limitParam = numberParams.find((p) => p.name === "limit");
+  if (limitParam) {
+    examples.push(`/${name} limit=10`);
+  }
+  return examples.slice(0, 3);
+}
+function generateSlashCommand(tool, tierOverride) {
+  const { name, description, inputSchema } = tool;
+  const isZodSchema = inputSchema instanceof import_zod.z.ZodType;
+  const parameters = isZodSchema ? extractParametersFromZod(inputSchema) : extractParametersFromJsonSchema(inputSchema);
+  const category = extractCategory(name);
+  const requiredTier = tierOverride || tool.requiredTier || "free";
+  const helpText = generateHelpText(name, description, parameters);
+  const examples = generateExamples(name, parameters);
+  return {
+    name,
+    description,
+    schema: isZodSchema ? inputSchema : createSchemaFromJsonSchema(inputSchema),
+    category,
+    requiredTier,
+    parameters,
+    helpText,
+    examples
+  };
+}
+function extractParametersFromJsonSchema(jsonSchema) {
+  const parameters = [];
+  if (jsonSchema.type !== "object" || !jsonSchema.properties) {
+    return parameters;
+  }
+  const properties = jsonSchema.properties;
+  const required = jsonSchema.required || [];
+  for (const [name, propSchema] of Object.entries(properties)) {
+    const param = {
+      name,
+      type: mapJsonSchemaType(propSchema.type),
+      description: propSchema.description || "",
+      required: required.includes(name),
+      defaultValue: propSchema.default,
+      enumValues: propSchema.enum
+    };
+    parameters.push(param);
+  }
+  return parameters;
+}
+function mapJsonSchemaType(jsonType) {
+  switch (jsonType) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return "array";
+    case "object":
+      return "object";
+    default:
+      return "string";
+  }
+}
+function createSchemaFromJsonSchema(jsonSchema) {
+  if (jsonSchema.type !== "object" || !jsonSchema.properties) {
+    return import_zod.z.object({});
+  }
+  const properties = jsonSchema.properties;
+  const required = new Set(jsonSchema.required || []);
+  const shape = {};
+  for (const [name, propSchema] of Object.entries(properties)) {
+    let fieldSchema = createFieldSchema(propSchema);
+    if (!required.has(name)) {
+      fieldSchema = fieldSchema.optional();
+    }
+    if (propSchema.description) {
+      fieldSchema = fieldSchema.describe(propSchema.description);
+    }
+    shape[name] = fieldSchema;
+  }
+  return import_zod.z.object(shape);
+}
+function createFieldSchema(propSchema) {
+  const type = propSchema.type;
+  if (propSchema.enum && Array.isArray(propSchema.enum)) {
+    return import_zod.z.enum(propSchema.enum);
+  }
+  switch (type) {
+    case "string":
+      return import_zod.z.string();
+    case "number":
+    case "integer":
+      return import_zod.z.number();
+    case "boolean":
+      return import_zod.z.boolean();
+    case "array":
+      return import_zod.z.array(import_zod.z.unknown());
+    case "object":
+      return import_zod.z.record(import_zod.z.unknown());
+    default:
+      return import_zod.z.unknown();
+  }
+}
+function generateSlashCommands(tools) {
+  return tools.map((tool) => generateSlashCommand(tool));
+}
+function generateAliases(name) {
+  const aliases = [];
+  const parts = name.split("_");
+  if (parts.length > 1) {
+    const acronym = parts.map((p) => p[0]).join("");
+    aliases.push(acronym);
+  }
+  const kebab = name.replace(/_/g, "-");
+  if (kebab !== name) {
+    aliases.push(kebab);
+  }
+  return aliases;
+}
+
+// src/parser.ts
+var DEFAULT_OPTIONS = {
+  allowUnknownArgs: false,
+  coerceTypes: true,
+  argSeparator: " "
+};
+function isSlashCommand(input) {
+  return input.trim().startsWith("/");
+}
+function extractCommandName(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) {
+    return "";
+  }
+  const withoutSlash = trimmed.slice(1);
+  const match = withoutSlash.match(/^([\w-]+)/);
+  return match ? match[1] : "";
+}
+function parseSlashCommand(input, registry, options = {}) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) {
+    return {
+      command: "",
+      args: {},
+      raw: input,
+      found: false,
+      errors: ["Input must start with /"]
+    };
+  }
+  const withoutSlash = trimmed.slice(1);
+  const tokens = tokenize(withoutSlash);
+  if (tokens.length === 0) {
+    return {
+      command: "",
+      args: {},
+      raw: input,
+      found: false,
+      errors: ["No command specified"]
+    };
+  }
+  const { command, argTokens } = resolveCommand(tokens, registry);
+  const { args, errors } = parseArguments(argTokens, opts);
+  const definition = registry?.get(command);
+  const found = registry ? !!definition : true;
+  const validationErrors = definition ? validateArgs(args, definition, opts) : [];
+  return {
+    command,
+    args,
+    raw: input,
+    found,
+    errors: [...errors, ...validationErrors].length > 0 ? [...errors, ...validationErrors] : void 0,
+    definition
+  };
+}
+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;
+        quoteChar = "";
+      } else {
+        current += char;
+      }
+    } else if (char === '"' || char === "'") {
+      inQuote = true;
+      quoteChar = char;
+    } else if (char === " " || char === "	") {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+function resolveCommand(tokens, registry) {
+  const firstToken = tokens[0];
+  if (registry?.has(firstToken)) {
+    return { command: firstToken, argTokens: tokens.slice(1) };
+  }
+  if (tokens.length > 1) {
+    const combined = `${firstToken}_${tokens[1]}`;
+    if (registry?.has(combined)) {
+      return { command: combined, argTokens: tokens.slice(2) };
+    }
+  }
+  const snakeCase = firstToken.replace(/-/g, "_");
+  if (registry?.has(snakeCase)) {
+    return { command: snakeCase, argTokens: tokens.slice(1) };
+  }
+  return { command: firstToken, argTokens: tokens.slice(1) };
+}
+function parseArguments(tokens, opts) {
+  const args = {};
+  const errors = [];
+  let i = 0;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    if (token.startsWith("-")) {
+      const eqIndex2 = token.indexOf("=");
+      if (eqIndex2 > 0) {
+        const key2 = token.slice(token.startsWith("--") ? 2 : 1, eqIndex2);
+        const value = token.slice(eqIndex2 + 1);
+        args[key2] = opts.coerceTypes ? coerceValue(value) : value;
+        i++;
+        continue;
+      }
+      const key = token.slice(token.startsWith("--") ? 2 : 1);
+      if (i + 1 < tokens.length && !tokens[i + 1].startsWith("-")) {
+        const value = tokens[i + 1];
+        args[key] = opts.coerceTypes ? coerceValue(value) : value;
+        i += 2;
+      } else {
+        args[key] = true;
+        i++;
+      }
+      continue;
+    }
+    const eqIndex = token.indexOf("=");
+    if (eqIndex > 0) {
+      const key = token.slice(0, eqIndex);
+      const value = token.slice(eqIndex + 1);
+      args[key] = opts.coerceTypes ? coerceValue(value) : value;
+      i++;
+      continue;
+    }
+    errors.push(`Unknown argument format: ${token}`);
+    i++;
+  }
+  return { args, errors };
+}
+function coerceValue(value) {
+  if (value.toLowerCase() === "true") return true;
+  if (value.toLowerCase() === "false") return false;
+  if (value.toLowerCase() === "null") return null;
+  if (value.toLowerCase() === "undefined") return void 0;
+  if (/^-?\d+$/.test(value)) {
+    return parseInt(value, 10);
+  }
+  if (/^-?\d+\.\d+$/.test(value)) {
+    return parseFloat(value);
+  }
+  if (value.startsWith("[") && value.endsWith("]") || value.startsWith("{") && value.endsWith("}")) {
+    try {
+      return JSON.parse(value);
+    } catch {
+    }
+  }
+  return value;
+}
+function validateArgs(args, definition, opts) {
+  const errors = [];
+  const paramNames = new Set(definition.parameters.map((p) => p.name));
+  if (!opts.allowUnknownArgs) {
+    for (const key of Object.keys(args)) {
+      if (!paramNames.has(key)) {
+        errors.push(`Unknown argument: ${key}`);
+      }
+    }
+  }
+  for (const param of definition.parameters) {
+    if (param.required && !(param.name in args)) {
+      errors.push(`Missing required argument: ${param.name}`);
+    }
+  }
+  for (const param of definition.parameters) {
+    if (param.enumValues && param.name in args) {
+      const value = args[param.name];
+      if (typeof value === "string" && !param.enumValues.includes(value)) {
+        errors.push(
+          `Invalid value for ${param.name}: '${value}'. Expected one of: ${param.enumValues.join(", ")}`
+        );
+      }
+    }
+  }
+  for (const param of definition.parameters) {
+    if (param.name in args) {
+      const value = args[param.name];
+      const typeError = validateType(value, param.type);
+      if (typeError) {
+        errors.push(`${param.name}: ${typeError}`);
+      }
+    }
+  }
+  return errors;
+}
+function validateType(value, expectedType) {
+  const actualType = typeof value;
+  switch (expectedType) {
+    case "string":
+      if (actualType !== "string") {
+        return `expected string, got ${actualType}`;
+      }
+      break;
+    case "number":
+      if (actualType !== "number" || isNaN(value)) {
+        return `expected number, got ${actualType}`;
+      }
+      break;
+    case "boolean":
+      if (actualType !== "boolean") {
+        return `expected boolean, got ${actualType}`;
+      }
+      break;
+    case "array":
+      if (!Array.isArray(value)) {
+        return `expected array, got ${actualType}`;
+      }
+      break;
+    case "object":
+      if (actualType !== "object" || value === null || Array.isArray(value)) {
+        return `expected object, got ${actualType}`;
+      }
+      break;
+  }
+  return null;
+}
+function formatCommand(command, args) {
+  const parts = [`/${command}`];
+  for (const [key, value] of Object.entries(args)) {
+    if (typeof value === "string" && value.includes(" ")) {
+      parts.push(`${key}="${value}"`);
+    } else if (typeof value === "object") {
+      parts.push(`${key}=${JSON.stringify(value)}`);
+    } else {
+      parts.push(`${key}=${value}`);
+    }
+  }
+  return parts.join(" ");
+}
+function getPartialCommand(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) {
+    return { command: "", isComplete: false };
+  }
+  const withoutSlash = trimmed.slice(1);
+  const spaceIndex = withoutSlash.indexOf(" ");
+  if (spaceIndex === -1) {
+    return { command: withoutSlash, isComplete: false };
+  }
+  const command = withoutSlash.slice(0, spaceIndex);
+  const rest = withoutSlash.slice(spaceIndex + 1).trim();
+  const lastToken = rest.split(" ").pop() || "";
+  const isTypingArg = !lastToken.includes("=") || lastToken.endsWith("=");
+  return {
+    command,
+    isComplete: true,
+    partialArg: isTypingArg ? lastToken : void 0
+  };
+}
+
+// src/registry.ts
+var SlashCommandRegistry = class {
+  constructor() {
+    this.commands = /* @__PURE__ */ new Map();
+    this.aliases = /* @__PURE__ */ new Map();
+    // alias -> command name
+    this.categories = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Register a single slash command
+   */
+  register(command) {
+    this.commands.set(command.name, command);
+    this.categories.add(command.category);
+    if (command.aliases) {
+      for (const alias of command.aliases) {
+        this.aliases.set(alias, command.name);
+      }
+    }
+    const autoAliases = generateAliases(command.name);
+    for (const alias of autoAliases) {
+      if (!this.aliases.has(alias) && !this.commands.has(alias)) {
+        this.aliases.set(alias, command.name);
+      }
+    }
+  }
+  /**
+   * Register multiple commands at once
+   */
+  registerAll(commands) {
+    for (const command of commands) {
+      this.register(command);
+    }
+  }
+  /**
+   * Register commands from tool definitions
+   */
+  registerFromTools(tools) {
+    for (const tool of tools) {
+      const command = generateSlashCommand(tool);
+      this.register(command);
+    }
+  }
+  /**
+   * Get a command by name or alias
+   */
+  get(nameOrAlias) {
+    const direct = this.commands.get(nameOrAlias);
+    if (direct) return direct;
+    const resolvedName = this.aliases.get(nameOrAlias);
+    if (resolvedName) {
+      return this.commands.get(resolvedName);
+    }
+    const snakeCase = nameOrAlias.replace(/-/g, "_");
+    return this.commands.get(snakeCase);
+  }
+  /**
+   * Check if a command exists
+   */
+  has(nameOrAlias) {
+    return this.get(nameOrAlias) !== void 0;
+  }
+  /**
+   * Get all registered commands
+   */
+  getAll() {
+    return Array.from(this.commands.values());
+  }
+  /**
+   * Get commands filtered by category
+   */
+  getByCategory(category) {
+    return this.getAll().filter((cmd) => cmd.category === category);
+  }
+  /**
+   * Get commands available for a subscription tier
+   */
+  getForTier(tier) {
+    const tierOrder = [
+      "free",
+      "premium",
+      "ultra-premium",
+      "enterprise"
+    ];
+    const tierIndex = tierOrder.indexOf(tier);
+    return this.getAll().filter((cmd) => {
+      const cmdTierIndex = tierOrder.indexOf(cmd.requiredTier);
+      return cmdTierIndex <= tierIndex;
+    });
+  }
+  /**
+   * Get all categories
+   */
+  getCategories() {
+    return Array.from(this.categories).sort();
+  }
+  /**
+   * Get command count by category
+   */
+  getCountByCategory() {
+    const counts = {};
+    for (const category of this.categories) {
+      counts[category] = this.getByCategory(category).length;
+    }
+    return counts;
+  }
+  /**
+   * Resolve an alias to the canonical command name
+   */
+  resolveAlias(alias) {
+    return this.aliases.get(alias);
+  }
+  /**
+   * Get the underlying Map for direct access
+   */
+  getMap() {
+    return this.commands;
+  }
+  /**
+   * Clear all registered commands
+   */
+  clear() {
+    this.commands.clear();
+    this.aliases.clear();
+    this.categories.clear();
+  }
+  /**
+   * Get total command count
+   */
+  get size() {
+    return this.commands.size;
+  }
+};
+var slashCommandRegistry = new SlashCommandRegistry();
+async function executeSlashCommand(input, context, executor) {
+  const startTime = Date.now();
+  const parsed = parseSlashCommand(input, slashCommandRegistry.getMap());
+  if (!parsed.found) {
+    return {
+      success: false,
+      error: `Unknown command: ${parsed.command}`,
+      executionTimeMs: Date.now() - startTime,
+      command: parsed.command,
+      args: parsed.args
+    };
+  }
+  if (parsed.errors && parsed.errors.length > 0) {
+    return {
+      success: false,
+      error: parsed.errors.join("; "),
+      executionTimeMs: Date.now() - startTime,
+      command: parsed.command,
+      args: parsed.args
+    };
+  }
+  const definition = parsed.definition;
+  const tierOrder = [
+    "free",
+    "premium",
+    "ultra-premium",
+    "enterprise"
+  ];
+  const userTierIndex = tierOrder.indexOf(context.userTier);
+  const requiredTierIndex = tierOrder.indexOf(definition.requiredTier);
+  if (requiredTierIndex > userTierIndex) {
+    return {
+      success: false,
+      error: `This command requires ${definition.requiredTier} subscription`,
+      executionTimeMs: Date.now() - startTime,
+      command: parsed.command,
+      args: parsed.args
+    };
+  }
+  try {
+    const data = await executor(parsed.command, parsed.args, context);
+    return {
+      success: true,
+      data,
+      executionTimeMs: Date.now() - startTime,
+      command: parsed.command,
+      args: parsed.args
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+      executionTimeMs: Date.now() - startTime,
+      command: parsed.command,
+      args: parsed.args
+    };
+  }
+}
+function createAPIExecutor(apiBaseUrl, authToken) {
+  return async (command, args, context) => {
+    const url = `${apiBaseUrl}/api/slash-command`;
+    const token = authToken || context.authToken;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...token ? { Authorization: `Bearer ${token}` } : {}
+      },
+      body: JSON.stringify({
+        command,
+        args,
+        conversationId: context.conversationId
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`API error: ${response.status} - ${errorText}`);
+    }
+    return response.json();
+  };
+}
+function getAllSlashCommands() {
+  return slashCommandRegistry.getAll();
+}
+function getSlashCommand(name) {
+  return slashCommandRegistry.get(name);
+}
+function hasSlashCommand(name) {
+  return slashCommandRegistry.has(name);
+}
+
+// src/autocomplete.ts
+var DEFAULT_OPTIONS2 = {
+  maxSuggestions: 10,
+  userTier: "free",
+  includeHidden: false,
+  minScore: 0
+};
+function fuzzyMatch(query, target) {
+  if (!query) return 50;
+  if (query === target) return 100;
+  const q = query.toLowerCase();
+  const t = target.toLowerCase();
+  if (t.startsWith(q)) {
+    return 90 + q.length / t.length * 10;
+  }
+  const words = t.split(/[_\-\s]/);
+  const initials = words.map((w) => w[0]).join("");
+  if (initials.startsWith(q)) {
+    return 80 + q.length / initials.length * 10;
+  }
+  if (t.includes(q)) {
+    const position = t.indexOf(q);
+    const positionScore = Math.max(0, 70 - position * 2);
+    return positionScore;
+  }
+  let qIndex = 0;
+  let matchCount = 0;
+  let consecutiveBonus = 0;
+  let lastMatchIndex = -2;
+  for (let i = 0; i < t.length && qIndex < q.length; i++) {
+    if (t[i] === q[qIndex]) {
+      matchCount++;
+      if (i === lastMatchIndex + 1) {
+        consecutiveBonus += 5;
+      }
+      lastMatchIndex = i;
+      qIndex++;
+    }
+  }
+  if (qIndex === q.length) {
+    const matchRatio = matchCount / q.length;
+    const lengthPenalty = Math.max(0, 1 - (t.length - q.length) / 20);
+    return Math.min(
+      60,
+      30 + matchRatio * 20 + consecutiveBonus + lengthPenalty * 10
+    );
+  }
+  return 0;
+}
+function getAutocompleteSuggestions(input, options = {}, registry = slashCommandRegistry) {
+  const opts = { ...DEFAULT_OPTIONS2, ...options };
+  const partial = getPartialCommand(input);
+  const tierOrder = [
+    "free",
+    "premium",
+    "ultra-premium",
+    "enterprise"
+  ];
+  const userTierIndex = tierOrder.indexOf(opts.userTier);
+  const allCommands = registry.getAll().filter((cmd) => {
+    if (cmd.hidden && !opts.includeHidden) return false;
+    return true;
+  });
+  if (!partial.isComplete) {
+    return suggestCommands(
+      partial.command,
+      allCommands,
+      opts,
+      userTierIndex,
+      tierOrder
+    );
+  }
+  const command = registry.get(partial.command);
+  if (command && partial.partialArg !== void 0) {
+    return suggestArguments(
+      command,
+      partial.partialArg,
+      opts,
+      userTierIndex,
+      tierOrder
+    );
+  }
+  if (command) {
+    return suggestArguments(command, "", opts, userTierIndex, tierOrder);
+  }
+  return [];
+}
+function suggestCommands(query, commands, opts, userTierIndex, tierOrder) {
+  const suggestions = [];
+  for (const cmd of commands) {
+    const score = fuzzyMatch(query, cmd.name);
+    if (score < opts.minScore) continue;
+    const cmdTierIndex = tierOrder.indexOf(cmd.requiredTier);
+    const hasAccess = cmdTierIndex <= userTierIndex;
+    suggestions.push({
+      command: cmd.name,
+      displayText: `/${cmd.name}`,
+      description: truncateDescription(cmd.description),
+      matchScore: score,
+      category: cmd.category,
+      hasAccess
+    });
+  }
+  suggestions.sort((a, b) => {
+    if (a.hasAccess !== b.hasAccess) {
+      return a.hasAccess ? -1 : 1;
+    }
+    if ((b.matchScore ?? 0) !== (a.matchScore ?? 0)) {
+      return (b.matchScore ?? 0) - (a.matchScore ?? 0);
+    }
+    return a.command.localeCompare(b.command);
+  });
+  return suggestions.slice(0, opts.maxSuggestions);
+}
+function suggestArguments(command, query, opts, userTierIndex, tierOrder) {
+  const suggestions = [];
+  const cmdTierIndex = tierOrder.indexOf(command.requiredTier);
+  const hasAccess = cmdTierIndex <= userTierIndex;
+  const eqIndex = query.indexOf("=");
+  if (eqIndex > 0) {
+    const argName = query.slice(0, eqIndex).replace(/^-+/, "");
+    const valuePrefix = query.slice(eqIndex + 1);
+    const param = command.parameters.find((p) => p.name === argName);
+    if (param?.enumValues) {
+      for (const value of param.enumValues) {
+        const score = fuzzyMatch(valuePrefix, value);
+        if (score < opts.minScore) continue;
+        suggestions.push({
+          command: `${argName}=${value}`,
+          displayText: `${argName}=${value}`,
+          description: `Set ${argName} to ${value}`,
+          matchScore: score,
+          category: "value",
+          hasAccess
+        });
+      }
+    }
+  } else {
+    const argQuery = query.replace(/^-+/, "");
+    for (const param of command.parameters) {
+      const score = fuzzyMatch(argQuery, param.name);
+      if (score < opts.minScore) continue;
+      const requiredTag = param.required ? " (required)" : "";
+      const typeTag = param.enumValues ? ` [${param.enumValues.slice(0, 3).join("|")}${param.enumValues.length > 3 ? "..." : ""}]` : ` <${param.type}>`;
+      suggestions.push({
+        command: param.name,
+        displayText: `${param.name}${typeTag}`,
+        description: param.description || `${param.name}${requiredTag}`,
+        matchScore: score,
+        category: "argument",
+        hasAccess
+      });
+    }
+  }
+  suggestions.sort((a, b) => {
+    if ((b.matchScore ?? 0) !== (a.matchScore ?? 0)) {
+      return (b.matchScore ?? 0) - (a.matchScore ?? 0);
+    }
+    return a.command.localeCompare(b.command);
+  });
+  return suggestions.slice(0, opts.maxSuggestions);
+}
+function truncateDescription(description, maxLength = 80) {
+  const firstLine = description.split("\n")[0];
+  const firstSentence = firstLine.split(/[.!?]/)[0];
+  const text = firstSentence || firstLine;
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength - 3) + "...";
+}
+function getSuggestionsGroupedByCategory(input, options = {}, registry = slashCommandRegistry) {
+  const suggestions = getAutocompleteSuggestions(input, options, registry);
+  const grouped = {};
+  for (const suggestion of suggestions) {
+    if (!grouped[suggestion.category]) {
+      grouped[suggestion.category] = [];
+    }
+    grouped[suggestion.category].push(suggestion);
+  }
+  return grouped;
+}
+function shouldShowAutocomplete(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) {
+    return false;
+  }
+  return true;
+}
+function getReplacementRange(input) {
+  const partial = getPartialCommand(input);
+  if (!partial.isComplete) {
+    return { start: 0, end: input.length };
+  }
+  if (partial.partialArg !== void 0) {
+    const start = input.lastIndexOf(partial.partialArg);
+    return { start, end: input.length };
+  }
+  return { start: input.length, end: input.length };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SlashCommandRegistry,
+  createAPIExecutor,
+  executeSlashCommand,
+  extractCategory,
+  extractCommandName,
+  extractParametersFromJsonSchema,
+  extractParametersFromZod,
+  formatCommand,
+  fuzzyMatch,
+  generateAliases,
+  generateExamples,
+  generateHelpText,
+  generateSlashCommand,
+  generateSlashCommands,
+  getAllSlashCommands,
+  getAutocompleteSuggestions,
+  getPartialCommand,
+  getReplacementRange,
+  getSlashCommand,
+  getSuggestionsGroupedByCategory,
+  hasSlashCommand,
+  isSlashCommand,
+  parseSlashCommand,
+  shouldShowAutocomplete,
+  slashCommandRegistry
+});