plugsuits 1.0.0

package/src/commands/aliases-and-tool-fallback.test.ts

@@ -0,0 +1,172 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { agentManager } from "../agent";
+import {
+  DEFAULT_TOOL_FALLBACK_MODE,
+  LEGACY_ENABLED_TOOL_FALLBACK_MODE,
+  TOOL_FALLBACK_MODES,
+  type ToolFallbackMode,
+} from "../tool-fallback-mode";
+import { createHelpCommand } from "./help";
+import { executeCommand, getCommands, registerCommand } from "./index";
+import { createReasoningModeCommand } from "./reasoning-mode";
+import { createToolFallbackCommand } from "./tool-fallback";
+import type { Command } from "./types";
+
+let commandCounter = 0;
+
+const nextCommandName = (prefix: string): string => {
+  commandCounter += 1;
+  return `${prefix}-${commandCounter}`;
+};
+
+describe("Command aliases", () => {
+  it("executes canonical command via alias", async () => {
+    const canonicalName = nextCommandName("clear");
+    const aliasName = nextCommandName("new");
+
+    registerCommand({
+      name: canonicalName,
+      aliases: [aliasName],
+      description: "Alias command test",
+      execute: () => ({
+        success: true,
+        message: `resolved:${canonicalName}`,
+      }),
+    });
+
+    const result = await executeCommand(`/${aliasName}`);
+
+    expect(result).not.toBeNull();
+    expect(result?.success).toBe(true);
+    expect(result?.message).toBe(`resolved:${canonicalName}`);
+  });
+
+  it("renders merged display name in help output", async () => {
+    const commandMap = new Map<string, Command>();
+    commandMap.set("clear", {
+      name: "clear",
+      displayName: "clear (new)",
+      aliases: ["new"],
+      description: "Start a new session",
+      execute: () => ({ success: true, action: "new-session" }),
+    });
+
+    const help = createHelpCommand(() => commandMap);
+    const result = await help.execute({ args: [] });
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain("/clear (new) - Start a new session");
+    expect(result.message).not.toContain("/new - Start a new session");
+  });
+});
+
+describe("Skill command prefixes", () => {
+  it("keeps non-command skills addressable without prompts prefix", async () => {
+    const result = await executeCommand("/example");
+
+    expect(result).not.toBeNull();
+    expect(result?.success).toBe(true);
+    expect(result && "isSkill" in result && result.isSkill).toBe(true);
+
+    if (result && "isSkill" in result && result.isSkill) {
+      expect(result.skillId).toBe("prompts:example");
+    }
+  });
+
+  it("resolves prompts prefix for non-command skills", async () => {
+    const result = await executeCommand("/prompts:example");
+
+    expect(result).not.toBeNull();
+    expect(result?.success).toBe(true);
+    expect(result && "isSkill" in result && result.isSkill).toBe(true);
+
+    if (result && "isSkill" in result && result.isSkill) {
+      expect(result.skillId).toBe("prompts:example");
+    }
+  });
+});
+
+describe("Reasoning mode command", () => {
+  let originalMode: ReturnType<typeof agentManager.getReasoningMode>;
+  let originalProvider: ReturnType<typeof agentManager.getProvider>;
+  let originalModelId: ReturnType<typeof agentManager.getModelId>;
+
+  beforeEach(() => {
+    originalMode = agentManager.getReasoningMode();
+    originalProvider = agentManager.getProvider();
+    originalModelId = agentManager.getModelId();
+    agentManager.setProvider("friendli");
+    agentManager.setModelId("MiniMaxAI/MiniMax-M2.5");
+    agentManager.setReasoningMode("on");
+  });
+
+  afterEach(() => {
+    agentManager.setProvider(originalProvider);
+    agentManager.setModelId(originalModelId);
+    agentManager.setReasoningMode(originalMode);
+  });
+
+  it("supports /think alias for /reasoning-mode", async () => {
+    if (!getCommands().has("reasoning-mode")) {
+      registerCommand(createReasoningModeCommand());
+    }
+
+    const result = await executeCommand("/think interleaved");
+    expect(result).not.toBeNull();
+    expect(result?.success).toBe(true);
+    expect(agentManager.getReasoningMode()).toBe("interleaved");
+  });
+
+  it("rejects unsupported mode for current model", async () => {
+    if (!getCommands().has("reasoning-mode")) {
+      registerCommand(createReasoningModeCommand());
+    }
+
+    const result = await executeCommand("/reasoning-mode preserved");
+    expect(result).not.toBeNull();
+    expect(result?.success).toBe(false);
+    expect(result?.message).toContain("not supported");
+  });
+});
+
+describe("Tool fallback command", () => {
+  let originalMode: ToolFallbackMode;
+
+  beforeEach(() => {
+    originalMode = agentManager.getToolFallbackMode();
+  });
+
+  afterEach(() => {
+    agentManager.setToolFallbackMode(originalMode);
+  });
+
+  it("shows mode usage when called without arguments", async () => {
+    const command = createToolFallbackCommand();
+    const result = await command.execute({ args: [] });
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain("Tool fallback mode:");
+    expect(result.message).toContain(TOOL_FALLBACK_MODES.join("|"));
+  });
+
+  it("sets explicit mode values", async () => {
+    const command = createToolFallbackCommand();
+
+    const result = await command.execute({ args: ["hermes"] });
+
+    expect(result.success).toBe(true);
+    expect(agentManager.getToolFallbackMode()).toBe("hermes");
+  });
+
+  it("accepts legacy on/off values", async () => {
+    const command = createToolFallbackCommand();
+
+    await command.execute({ args: ["on"] });
+    expect(agentManager.getToolFallbackMode()).toBe(
+      LEGACY_ENABLED_TOOL_FALLBACK_MODE
+    );
+
+    await command.execute({ args: ["off"] });
+    expect(agentManager.getToolFallbackMode()).toBe(DEFAULT_TOOL_FALLBACK_MODE);
+  });
+});

package/src/commands/clear.ts

@@ -0,0 +1,14 @@
+import type { Command, CommandResult } from "./types";
+
+const newSessionAction = (): CommandResult => ({
+  success: true,
+  action: "new-session",
+});
+
+export const createClearCommand = (): Command => ({
+  name: "clear",
+  displayName: "clear (new)",
+  aliases: ["new"],
+  description: "Start a new session",
+  execute: () => newSessionAction(),
+});

package/src/commands/factories/create-toggle-command.ts

@@ -0,0 +1,68 @@
+import { colorize } from "../../interaction/colors";
+import type { Command, CommandResult } from "../types";
+
+interface ToggleCommandConfig {
+  description: string;
+  disabledMessage?: string;
+  enabledMessage?: string;
+  featureName: string;
+  getter: () => boolean;
+  name: string;
+  setter: (value: boolean) => void;
+}
+
+export function createToggleCommand(config: ToggleCommandConfig): Command {
+  const {
+    name,
+    description,
+    getter,
+    setter,
+    featureName,
+    enabledMessage,
+    disabledMessage,
+  } = config;
+
+  return {
+    name,
+    description,
+    argumentSuggestions: ["on", "off"],
+    execute: ({ args }): CommandResult => {
+      if (args.length === 0) {
+        const currentStatus = getter();
+        return {
+          success: true,
+          message: `${featureName} is currently ${colorize(currentStatus ? "green" : "red", currentStatus ? "enabled" : "disabled")}.\nUsage: /${name} <on|off>`,
+        };
+      }
+
+      const action = args[0]?.toLowerCase();
+
+      if (action === "on" || action === "enable" || action === "true") {
+        setter(true);
+        return {
+          success: true,
+          message: colorize(
+            "green",
+            enabledMessage || `${featureName} enabled`
+          ),
+        };
+      }
+
+      if (action === "off" || action === "disable" || action === "false") {
+        setter(false);
+        return {
+          success: true,
+          message: colorize(
+            "yellow",
+            disabledMessage || `${featureName} disabled`
+          ),
+        };
+      }
+
+      return {
+        success: false,
+        message: `Invalid argument: ${action}. Use 'on' or 'off'.`,
+      };
+    },
+  };
+}

package/src/commands/help.ts

@@ -0,0 +1,30 @@
+import type { Command, CommandResult } from "./types";
+
+export const createHelpCommand = (
+  getCommands: () => Map<string, Command>
+): Command => ({
+  name: "help",
+  description: "Show available commands",
+  execute: (): CommandResult => {
+    const getCommandName = (command: Command): string => {
+      if (command.displayName) {
+        return command.displayName;
+      }
+
+      if (command.aliases && command.aliases.length > 0) {
+        return `${command.name} (${command.aliases.join(", ")})`;
+      }
+
+      return command.name;
+    };
+
+    const commandList = Array.from(getCommands().values())
+      .map((cmd) => `  /${getCommandName(cmd)} - ${cmd.description}`)
+      .join("\n");
+
+    return {
+      success: true,
+      message: `Available commands:\n${commandList}`,
+    };
+  },
+});

package/src/commands/index.ts

@@ -0,0 +1,125 @@
+import { toPromptsCommandName } from "../context/skill-command-prefix";
+import { loadSkillById } from "../context/skills";
+import { createHelpCommand } from "./help";
+import type { Command, CommandContext, CommandResult } from "./types";
+
+export interface SkillCommandResult extends CommandResult {
+  isSkill: true;
+  skillContent: string;
+  skillId: string;
+}
+
+const commands = new Map<string, Command>();
+const commandAliases = new Map<string, string>();
+
+const getCommands = (): Map<string, Command> => commands;
+
+export { getCommands };
+
+export const registerCommand = (command: Command): void => {
+  const normalizedName = command.name.toLowerCase();
+
+  if (commands.has(normalizedName)) {
+    throw new Error(`Duplicate command name: ${normalizedName}`);
+  }
+
+  const aliases = command.aliases?.map((alias) => alias.toLowerCase()) ?? [];
+  const normalizedCommand: Command = {
+    ...command,
+    name: normalizedName,
+    aliases,
+  };
+  commands.set(normalizedName, normalizedCommand);
+
+  for (const alias of aliases) {
+    if (alias === normalizedName) {
+      continue;
+    }
+
+    if (commands.has(alias)) {
+      throw new Error(
+        `Alias '${alias}' for /${normalizedName} conflicts with command /${alias}`
+      );
+    }
+
+    const existingTarget = commandAliases.get(alias);
+    if (existingTarget && existingTarget !== normalizedName) {
+      throw new Error(
+        `Alias '${alias}' for /${normalizedName} already maps to /${existingTarget}`
+      );
+    }
+
+    commandAliases.set(alias, normalizedName);
+  }
+};
+
+export const resolveRegisteredCommandName = (name: string): string => {
+  const normalizedName = name.toLowerCase();
+  return commandAliases.get(normalizedName) ?? normalizedName;
+};
+
+registerCommand(createHelpCommand(getCommands));
+
+const COMMAND_PREFIX = "/";
+const WHITESPACE_REGEX = /\s+/;
+
+export const isCommand = (input: string): boolean =>
+  input.startsWith(COMMAND_PREFIX);
+
+export const parseCommand = (
+  input: string
+): { name: string; args: string[] } | null => {
+  if (!isCommand(input)) {
+    return null;
+  }
+
+  const parts = input.slice(COMMAND_PREFIX.length).split(WHITESPACE_REGEX);
+  const name = parts[0]?.toLowerCase();
+
+  if (!name) {
+    return null;
+  }
+
+  return { name, args: parts.slice(1) };
+};
+
+export const executeCommand = async (
+  input: string
+): Promise<CommandResult | SkillCommandResult | null> => {
+  const parsed = parseCommand(input);
+
+  if (!parsed) {
+    return null;
+  }
+
+  const resolvedName = resolveRegisteredCommandName(parsed.name);
+  const command = commands.get(resolvedName);
+
+  if (!command) {
+    // Check if it's a skill
+    const skill = await loadSkillById(parsed.name);
+    if (skill) {
+      return {
+        success: true,
+        isSkill: true,
+        skillId: toPromptsCommandName(skill.info.id),
+        skillContent: skill.content,
+      } as SkillCommandResult;
+    }
+
+    return {
+      success: false,
+      message: `Unknown command: /${parsed.name}. Type /help for available commands.`,
+    };
+  }
+
+  const context: CommandContext = { args: parsed.args };
+
+  return await command.execute(context);
+};
+
+export const isSkillCommandResult = (
+  result: CommandResult | SkillCommandResult | null
+): result is SkillCommandResult => {
+  return result !== null && "isSkill" in result && result.isSkill === true;
+};

package/src/commands/model.ts

@@ -0,0 +1,146 @@
+import type { ProviderType } from "../agent";
+import { ANTHROPIC_MODELS, agentManager } from "../agent";
+import type { FriendliReasoningModelConfig } from "../friendli-models";
+import { FRIENDLI_MODELS } from "../friendli-models";
+import { colorize } from "../interaction/colors";
+import type { Command, CommandResult } from "./types";
+
+export interface ModelInfo {
+  id: string;
+  name?: string;
+  provider: ProviderType;
+  reasoning?: FriendliReasoningModelConfig | null;
+  type?: "serverless" | "dedicated";
+}
+
+function getAnthropicModels(): ModelInfo[] {
+  return ANTHROPIC_MODELS.map((m) => ({
+    id: m.id,
+    name: m.name,
+    provider: "anthropic" as const,
+  }));
+}
+
+export function getAvailableModels(): ModelInfo[] {
+  const anthropicModels = getAnthropicModels();
+
+  return [...anthropicModels, ...FRIENDLI_MODELS.filter((m) => !m.masked)];
+}
+
+export function findModelBySelection(
+  selection: string,
+  models: ModelInfo[] = getAvailableModels()
+): ModelInfo | undefined {
+  const selectedIndex = Number.parseInt(selection, 10) - 1;
+
+  if (
+    !Number.isNaN(selectedIndex) &&
+    selectedIndex >= 0 &&
+    selectedIndex < models.length
+  ) {
+    return models[selectedIndex];
+  }
+
+  return models.find((m) => m.id === selection);
+}
+
+const getProviderLabel = (provider: ProviderType): string => {
+  const providerLabels: Record<ProviderType, string> = {
+    anthropic: "Anthropic",
+    friendli: "FriendliAI",
+  };
+  return providerLabels[provider];
+};
+
+export const applyModelSelection = (
+  selectedModel: ModelInfo
+): CommandResult => {
+  const currentModelId = agentManager.getModelId();
+  const currentProvider = agentManager.getProvider();
+
+  if (
+    selectedModel.id === currentModelId &&
+    selectedModel.provider === currentProvider
+  ) {
+    return {
+      success: true,
+      message: `Already using model: ${selectedModel.id}`,
+    };
+  }
+
+  if (selectedModel.provider !== currentProvider) {
+    agentManager.setProvider(selectedModel.provider);
+  }
+
+  agentManager.setModelId(selectedModel.id);
+  if (selectedModel.type) {
+    agentManager.setModelType(selectedModel.type);
+  }
+
+  const providerLabel = getProviderLabel(selectedModel.provider);
+  return {
+    success: true,
+    message: colorize(
+      "green",
+      `Model changed to: ${selectedModel.id} (${providerLabel})`
+    ),
+  };
+};
+
+function formatModelList(
+  models: ModelInfo[],
+  currentModelId: string,
+  currentProvider: ProviderType
+): string {
+  const lines = models.map((model, index) => {
+    const isCurrent =
+      model.id === currentModelId && model.provider === currentProvider;
+    const marker = isCurrent ? colorize("green", " (current)") : "";
+    let providerLabel: string;
+    if (model.provider === "anthropic") {
+      providerLabel = colorize("magenta", " [Anthropic]");
+    } else if (model.type === "dedicated") {
+      providerLabel = colorize("cyan", " [FDE]");
+    } else {
+      providerLabel = colorize("blue", " [FriendliAI]");
+    }
+    const nameLabel = model.name ? ` - ${model.name}` : "";
+    return `  ${index + 1}. ${model.id}${nameLabel}${providerLabel}${marker}`;
+  });
+
+  return `Available models:\n${lines.join("\n")}\n\nUsage: /model <number> to select`;
+}
+
+export const createModelCommand = (): Command => ({
+  name: "model",
+  description: "List or change the AI model",
+  execute: ({ args }): CommandResult => {
+    const models = getAvailableModels();
+
+    if (models.length === 0) {
+      return { success: false, message: "No models available." };
+    }
+
+    const currentModelId = agentManager.getModelId();
+    const currentProvider = agentManager.getProvider();
+
+    if (args.length === 0) {
+      return {
+        success: true,
+        message: formatModelList(models, currentModelId, currentProvider),
+      };
+    }
+
+    const selection = args[0];
+    const selectedModel = findModelBySelection(selection, models);
+
+    if (!selectedModel) {
+      return {
+        success: false,
+        message: `Invalid selection: ${selection}`,
+      };
+    }
+
+    return applyModelSelection(selectedModel);
+  },
+});

package/src/commands/reasoning-mode.ts

@@ -0,0 +1,55 @@
+import { agentManager } from "../agent";
+import { parseReasoningMode, REASONING_MODES } from "../reasoning-mode";
+import type { Command } from "./types";
+
+const REASONING_MODE_USAGE = REASONING_MODES.join("|");
+
+export const createReasoningModeCommand = (): Command => ({
+  name: "reasoning-mode",
+  aliases: ["think"],
+  description: "Set reasoning mode (off/on/interleaved/preserved)",
+  argumentSuggestions: [...REASONING_MODES],
+  execute: ({ args }) => {
+    const selectableModes = agentManager.getSelectableReasoningModes();
+    const selectableLabel = selectableModes.join("|");
+
+    if (args.length === 0) {
+      const currentMode = agentManager.getReasoningMode();
+      return {
+        success: true,
+        message: `Reasoning mode: ${currentMode}\nSelectable: ${selectableLabel}\nUsage: /reasoning-mode <${REASONING_MODE_USAGE}>`,
+      };
+    }
+
+    const rawMode = args[0] ?? "";
+    const mode = parseReasoningMode(rawMode);
+    if (!mode) {
+      return {
+        success: false,
+        message: `Invalid mode: ${rawMode}. Use one of: ${REASONING_MODE_USAGE}`,
+      };
+    }
+
+    if (!selectableModes.includes(mode)) {
+      return {
+        success: false,
+        message: `Mode ${mode} is not supported for current model. Selectable: ${selectableLabel}`,
+      };
+    }
+
+    const currentMode = agentManager.getReasoningMode();
+    if (mode === currentMode) {
+      return {
+        success: true,
+        message: `Already using reasoning mode: ${mode}`,
+      };
+    }
+
+    agentManager.setReasoningMode(mode);
+
+    return {
+      success: true,
+      message: `Reasoning mode set to: ${mode}`,
+    };
+  },
+});

package/src/commands/render.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "bun:test";
+import type { ModelMessage } from "ai";
+import {
+  appendNextUserPromptSentinel,
+  NEXT_USER_PROMPT_SENTINEL,
+} from "./render";
+
+describe("render prompt shaping", () => {
+  it("appends the sentinel as the last user message", () => {
+    const messages: ModelMessage[] = [
+      {
+        role: "user",
+        content: "existing prompt",
+      },
+      {
+        role: "assistant",
+        content: "existing response",
+      },
+    ];
+
+    const withSentinel = appendNextUserPromptSentinel(messages);
+
+    expect(withSentinel).toHaveLength(3);
+    expect(withSentinel.at(-1)).toEqual({
+      role: "user",
+      content: NEXT_USER_PROMPT_SENTINEL,
+    });
+    expect(NEXT_USER_PROMPT_SENTINEL).toBe(
+      NEXT_USER_PROMPT_SENTINEL.toUpperCase()
+    );
+  });
+
+  it("does not mutate the original message array", () => {
+    const messages: ModelMessage[] = [
+      {
+        role: "assistant",
+        content: "final answer",
+      },
+    ];
+
+    const withSentinel = appendNextUserPromptSentinel(messages);
+
+    expect(messages).toHaveLength(1);
+    expect(withSentinel).not.toBe(messages);
+    expect(withSentinel).toHaveLength(2);
+  });
+});