plugsuits 1.0.0

package/src/commands/render.ts

@@ -0,0 +1,205 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import type { ModelMessage, ToolSet } from "ai";
+import { generateText, wrapLanguageModel } from "ai";
+import type { ModelType } from "../agent";
+import { env } from "../env";
+import {
+  applyFriendliInterleavedField,
+  buildFriendliChatTemplateKwargs,
+} from "../friendli-reasoning";
+import { colors } from "../interaction/colors";
+import { Spinner } from "../interaction/spinner";
+import { buildMiddlewares } from "../middleware";
+import type { ReasoningMode } from "../reasoning-mode";
+import type { ToolFallbackMode } from "../tool-fallback-mode";
+import type { Command, CommandResult } from "./types";
+
+interface RenderData {
+  instructions: string;
+  messages: ModelMessage[];
+  model: string;
+  modelType: ModelType;
+  reasoningMode: ReasoningMode;
+  toolFallbackMode: ToolFallbackMode;
+  tools: ToolSet;
+}
+
+export const NEXT_USER_PROMPT_SENTINEL =
+  "THE NEXT USER PROMPT IS LOCATED HERE.";
+
+export const appendNextUserPromptSentinel = (
+  messages: ModelMessage[]
+): ModelMessage[] => {
+  return [
+    ...messages,
+    {
+      role: "user",
+      content: NEXT_USER_PROMPT_SENTINEL,
+    },
+  ];
+};
+
+/**
+ * Render chat prompt to raw text.
+ *
+ * Why use generateText + capturedText pattern:
+ * - Request: Must go through AI SDK middleware and conversion layer
+ *   to match actual API request format (tool definitions, message format, etc.)
+ * - Response: Must show raw text AS-IS, but AI SDK parses XML tool calls
+ *   and strips them from result.text
+ *
+ * Solution: Capture raw API response before AI SDK processes it,
+ * return empty content to AI SDK so it has nothing to parse.
+ */
+async function renderChatPrompt({
+  model,
+  modelType,
+  instructions,
+  tools,
+  messages,
+  reasoningMode,
+  toolFallbackMode,
+}: RenderData): Promise<string> {
+  const isDedicated = modelType === "dedicated";
+  const baseURL = isDedicated
+    ? "https://api.friendli.ai/dedicated/v1"
+    : "https://api.friendli.ai/serverless/v1";
+
+  const chatTemplateKwargs = buildFriendliChatTemplateKwargs(
+    model,
+    reasoningMode
+  );
+  const messagesWithSentinel = appendNextUserPromptSentinel(messages);
+  const preparedMessages = applyFriendliInterleavedField(
+    messagesWithSentinel,
+    model,
+    reasoningMode
+  );
+
+  let capturedText = "";
+
+  const customFetch = Object.assign(
+    async (
+      _url: RequestInfo | URL,
+      options?: RequestInit
+    ): Promise<Response> => {
+      const parsedBody = options?.body
+        ? JSON.parse(options.body as string)
+        : {};
+      const { tool_choice: _ignored, ...bodyWithoutToolChoice } = parsedBody;
+
+      const endpoint = isDedicated
+        ? "https://api.friendli.ai/dedicated/v1/chat/render"
+        : "https://api.friendli.ai/serverless/v1/chat/render";
+
+      const resp = await fetch(endpoint, {
+        ...options,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers,
+        },
+        body: JSON.stringify({
+          ...bodyWithoutToolChoice,
+          ...(chatTemplateKwargs
+            ? { chat_template_kwargs: chatTemplateKwargs }
+            : {}),
+        }),
+      });
+
+      if (!resp.ok) {
+        const errorText = await resp.text();
+        throw new Error(`API error ${resp.status}: ${errorText}`);
+      }
+
+      const data = (await resp.json()) as { text: string };
+      capturedText = data.text;
+
+      const result = {
+        id: "chatcmpl-render",
+        model: "dummy",
+        object: "chat.completion",
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: "assistant",
+              content: "",
+            },
+            finish_reason: "stop",
+          },
+        ],
+        usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+        created: Date.now(),
+      };
+
+      return new Response(JSON.stringify(result), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    },
+    { preconnect: fetch.preconnect }
+  );
+
+  const friendli = createOpenAICompatible({
+    name: "friendli",
+    apiKey: env.FRIENDLI_TOKEN,
+    baseURL,
+    fetch: customFetch,
+  });
+
+  await generateText({
+    model: wrapLanguageModel({
+      model: friendli(model),
+      middleware: buildMiddlewares({
+        toolFallbackMode,
+      }),
+    }),
+    system: instructions,
+    tools,
+    messages: preparedMessages,
+  });
+
+  return capturedText;
+}
+
+const RENDER_TIMEOUT_MS = 5000;
+
+function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<never>((_, reject) =>
+      setTimeout(() => reject(new Error("timeout")), ms)
+    ),
+  ]);
+}
+
+export const createRenderCommand = (
+  getData: () => RenderData | Promise<RenderData>
+): Command => ({
+  name: "render",
+  description: "Render conversation as raw prompt text",
+  execute: async (): Promise<CommandResult> => {
+    const spinner = new Spinner("Rendering prompt...");
+    const data = await getData();
+
+    if (data.messages.length === 0) {
+      return { success: false, message: "No messages to render." };
+    }
+
+    try {
+      spinner.start();
+      const text = await withTimeout(renderChatPrompt(data), RENDER_TIMEOUT_MS);
+      spinner.stop();
+      const styledText = text
+        ? `${colors.dim}${text}${colors.reset}`
+        : "(empty render result)";
+      return { success: true, message: styledText };
+    } catch (error) {
+      spinner.stop();
+      const errorMessage =
+        error instanceof Error ? error.message : "Unknown error";
+      return { success: false, message: `Render failed: ${errorMessage}` };
+    }
+  },
+});

package/src/commands/tool-fallback.ts

@@ -0,0 +1,47 @@
+import { agentManager } from "../agent";
+import {
+  parseToolFallbackMode,
+  TOOL_FALLBACK_MODES,
+} from "../tool-fallback-mode";
+import type { Command } from "./types";
+
+const TOOL_FALLBACK_USAGE = TOOL_FALLBACK_MODES.join("|");
+
+export const createToolFallbackCommand = (): Command => ({
+  name: "tool-fallback",
+  description:
+    "Set tool call fallback mode for models without native tool support",
+  argumentSuggestions: [...TOOL_FALLBACK_MODES],
+  execute: ({ args }) => {
+    if (args.length === 0) {
+      const currentMode = agentManager.getToolFallbackMode();
+      return {
+        success: true,
+        message: `Tool fallback mode: ${currentMode}\nUsage: /tool-fallback <${TOOL_FALLBACK_USAGE}>`,
+      };
+    }
+
+    const rawMode = args[0] ?? "";
+    const mode = parseToolFallbackMode(rawMode);
+    if (!mode) {
+      return {
+        success: false,
+        message: `Invalid mode: ${rawMode}. Use one of: ${TOOL_FALLBACK_USAGE}`,
+      };
+    }
+
+    const currentMode = agentManager.getToolFallbackMode();
+    if (mode === currentMode) {
+      return {
+        success: true,
+        message: `Already using tool fallback mode: ${mode}`,
+      };
+    }
+
+    agentManager.setToolFallbackMode(mode);
+    return {
+      success: true,
+      message: `Tool fallback mode set to: ${mode}`,
+    };
+  },
+});

package/src/commands/translate.test.ts

@@ -0,0 +1,62 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import { agentManager } from "../agent";
+import { createTranslateCommand } from "./translate";
+
+describe("translate command", () => {
+  const command = createTranslateCommand();
+
+  beforeEach(() => { agentManager.resetForTesting(); });
+
+  it("reports current translation state when called without args", async () => {
+    agentManager.setTranslationEnabled(true);
+
+    const result = await command.execute({ args: [] });
+
+    expect(result?.success).toBe(true);
+    expect(result?.message).toContain("Translation is currently");
+    expect(result?.message).toContain("enabled");
+  });
+
+  it("enables translation with on/enable/true", async () => {
+    const onResult = await command.execute({ args: ["on"] });
+    expect(onResult?.success).toBe(true);
+    expect(agentManager.isTranslationEnabled()).toBe(true);
+    expect(onResult?.message).toContain("Translation enabled");
+
+    const enableResult = await command.execute({ args: ["enable"] });
+    expect(enableResult?.success).toBe(true);
+    expect(agentManager.isTranslationEnabled()).toBe(true);
+
+    const trueResult = await command.execute({ args: ["true"] });
+    expect(trueResult?.success).toBe(true);
+    expect(agentManager.isTranslationEnabled()).toBe(true);
+  });
+
+  it("disables translation with off/disable/false", async () => {
+    agentManager.setTranslationEnabled(true);
+
+    const offResult = await command.execute({ args: ["off"] });
+    expect(offResult?.success).toBe(true);
+    expect(agentManager.isTranslationEnabled()).toBe(false);
+    expect(offResult?.message).toContain("Translation disabled");
+
+    agentManager.setTranslationEnabled(true);
+    const disableResult = await command.execute({ args: ["disable"] });
+    expect(disableResult?.success).toBe(true);
+    expect(agentManager.isTranslationEnabled()).toBe(false);
+
+    agentManager.setTranslationEnabled(true);
+    const falseResult = await command.execute({ args: ["false"] });
+    expect(falseResult?.success).toBe(true);
+    expect(agentManager.isTranslationEnabled()).toBe(false);
+  });
+
+  it("rejects invalid arguments", async () => {
+    const result = await command.execute({ args: ["maybe"] });
+
+    expect(result?.success).toBe(false);
+    expect(result?.message).toContain("Invalid argument");
+    expect(result?.message).toContain("on");
+    expect(result?.message).toContain("off");
+  });
+});

package/src/commands/translate.ts

@@ -0,0 +1,14 @@
+import { agentManager } from "../agent";
+import { createToggleCommand } from "./factories/create-toggle-command";
+import type { Command } from "./types";
+
+export const createTranslateCommand = (): Command =>
+  createToggleCommand({
+    name: "translate",
+    description: "Toggle auto-translation of non-English prompts",
+    getter: () => agentManager.isTranslationEnabled(),
+    setter: (value) => agentManager.setTranslationEnabled(value),
+    featureName: "Translation",
+    enabledMessage: "Translation enabled",
+    disabledMessage: "Translation disabled",
+  });

package/src/commands/types.ts

@@ -0,0 +1,18 @@
+export interface CommandContext {
+  args: string[];
+}
+
+export interface CommandResult {
+  action?: "new-session";
+  message?: string;
+  success: boolean;
+}
+
+export interface Command {
+  aliases?: string[];
+  argumentSuggestions?: string[];
+  description: string;
+  displayName?: string;
+  execute: (context: CommandContext) => CommandResult | Promise<CommandResult>;
+  name: string;
+}

package/src/context/environment-context.ts

@@ -0,0 +1,11 @@
+export const getEnvironmentContext = (): string => {
+  const cwd = process.cwd();
+
+  return `
+## Environment
+
+- **Working Directory**: ${cwd}
+- **Path Resolution**: All relative paths are resolved from the working directory
+- **Shell Execution Model**: Each shell_execute invocation is isolated (no retained terminal context)
+`;
+};

package/src/context/paths.ts

@@ -0,0 +1,2 @@
+export const CEA_DIR = ".cea";
+export const TODO_DIR = `${CEA_DIR}/todos`;

package/src/context/session.ts

@@ -0,0 +1,18 @@
+import { randomUUID } from "node:crypto";
+let currentSessionId: string | null = null;
+
+export function initializeSession(): string {
+  currentSessionId = `session-${randomUUID()}`;
+  return currentSessionId;
+}
+
+export function getSessionId(): string {
+  if (!currentSessionId) {
+    throw new Error("Session not initialized. Call initializeSession() first.");
+  }
+  return currentSessionId;
+}
+
+export function hasActiveSession(): boolean {
+  return currentSessionId !== null;
+}

package/src/context/skill-command-prefix.ts

@@ -0,0 +1,18 @@
+export const PROMPTS_COMMAND_PREFIX = "prompts:";
+
+export const toPromptsCommandName = (skillId: string): string => {
+  if (skillId.startsWith(PROMPTS_COMMAND_PREFIX)) {
+    return skillId;
+  }
+
+  return `${PROMPTS_COMMAND_PREFIX}${skillId}`;
+};
+
+export const parsePromptsCommandName = (commandName: string): string | null => {
+  if (!commandName.startsWith(PROMPTS_COMMAND_PREFIX)) {
+    return null;
+  }
+
+  const skillId = commandName.slice(PROMPTS_COMMAND_PREFIX.length);
+  return skillId.length > 0 ? skillId : null;
+};

package/src/context/skills-integration.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, test } from "bun:test";
+import { executeLoadSkill } from "../tools/planning/load-skill";
+import {
+  parsePromptsCommandName,
+  toPromptsCommandName,
+} from "./skill-command-prefix";
+import { loadAllSkills, loadSkillById } from "./skills";
+
+describe("Skills Integration Tests", () => {
+  test("loads both legacy and v2 skills", async () => {
+    const skills = await loadAllSkills();
+
+    // Should have at least git-workflow (legacy) and example (v2)
+    expect(skills.length).toBeGreaterThanOrEqual(2);
+
+    const legacySkill = skills.find((s) => s.id === "git-workflow");
+    expect(legacySkill?.format).toBe("legacy");
+
+    const v2Skill = skills.find((s) => s.id === "example");
+    expect(v2Skill?.format).toBe("v2");
+  });
+
+  test("loads v2 skill with proper metadata", async () => {
+    const result = await loadSkillById("example");
+    expect(result).toBeTruthy();
+
+    if (result) {
+      expect(result.info.format).toBe("v2");
+      expect(result.info.name).toBe("example");
+      expect(result.info.description).toContain("agentskills.io");
+      expect(result.info.dirPath).toBeTruthy();
+      expect(result.content).toContain("# Example Skill");
+    }
+  });
+
+  test("executeLoadSkill works with v2 skills", async () => {
+    const result = await executeLoadSkill({ skillName: "example" });
+
+    expect(result).toContain("# Skill Loaded: example");
+    expect(result).toContain("[Bundled (v2)]");
+    expect(result).toContain("# Example Skill");
+  });
+
+  test("executeLoadSkill loads subdirectory files with relativePath", async () => {
+    const setupScript = await executeLoadSkill({
+      skillName: "example",
+      relativePath: "scripts/setup.sh",
+    });
+
+    expect(setupScript).toContain("# Skill File: example/scripts/setup.sh");
+    expect(setupScript).toContain("#!/bin/bash");
+    expect(setupScript).toContain("Setup script for example skill");
+
+    const apiDocs = await executeLoadSkill({
+      skillName: "example",
+      relativePath: "references/api.md",
+    });
+
+    expect(apiDocs).toContain("# Skill File: example/references/api.md");
+    expect(apiDocs).toContain("# API Reference");
+    expect(apiDocs).toContain("/api/health");
+  });
+
+  test("executeLoadSkill prevents path traversal", async () => {
+    const result = await executeLoadSkill({
+      skillName: "example",
+      relativePath: "../../../package.json",
+    });
+
+    expect(result).toContain("Error: Invalid relative path");
+    expect(result).toContain("cannot contain '..'");
+  });
+
+  test("executeLoadSkill rejects absolute paths", async () => {
+    const result = await executeLoadSkill({
+      skillName: "example",
+      relativePath: "/etc/passwd",
+    });
+
+    expect(result).toContain("Error: Invalid relative path");
+  });
+
+  test("executeLoadSkill with relativePath only works with v2 skills", async () => {
+    const result = await executeLoadSkill({
+      skillName: "git-workflow",
+      relativePath: "some-file.txt",
+    });
+
+    expect(result).toContain(
+      "Error: Skill 'git-workflow' is a legacy format skill"
+    );
+    expect(result).toContain("Only v2 skills support subdirectory files");
+  });
+
+  test("formats prompts-prefixed slash command names", () => {
+    expect(toPromptsCommandName("rams")).toBe("prompts:rams");
+    expect(toPromptsCommandName("prompts:rams")).toBe("prompts:rams");
+  });
+
+  test("parses prompts-prefixed slash command names", () => {
+    expect(parsePromptsCommandName("prompts:rams")).toBe("rams");
+    expect(parsePromptsCommandName("prompts:")).toBeNull();
+    expect(parsePromptsCommandName("rams")).toBeNull();
+  });
+
+  test("loads v2 skill by prompts-prefixed name", async () => {
+    const result = await loadSkillById("prompts:example");
+
+    expect(result).toBeTruthy();
+    expect(result?.info.id).toBe("example");
+    expect(result?.info.format).toBe("v2");
+  });
+});

package/src/context/skills.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "bun:test";
+import { loadSkillsMetadata } from "./skills";
+
+describe("loadSkillsMetadata", () => {
+  it("loads git-workflow skill metadata successfully", async () => {
+    const metadata = await loadSkillsMetadata();
+
+    expect(metadata).toContain("Git Workflow");
+    expect(metadata).toContain("git-workflow");
+    expect(metadata).toContain("Available Skills");
+  });
+
+  it("includes skill description", async () => {
+    const metadata = await loadSkillsMetadata();
+
+    expect(metadata).toContain("Complete git workflow");
+    expect(metadata).toContain("load_skill");
+  });
+
+  it("returns empty string if no skills directory", async () => {
+    const metadata = await loadSkillsMetadata();
+
+    expect(typeof metadata).toBe("string");
+  });
+});