wave-agent-sdk 1.0.4 → 1.0.6

package/src/utils/markdownParser.ts

@@ -1,317 +0,0 @@
-import { readFileSync, writeFileSync, mkdirSync } from "fs";
-import { exec } from "child_process";
-import { promisify } from "util";
-import { join } from "path";
-import { tmpdir } from "os";
-import type { CustomSlashCommandConfig } from "../types/index.js";
-import {
-  SKILL_BASH_MAX_OUTPUT_CHARS,
-  PREVIEW_SIZE_BYTES,
-} from "../constants/toolLimits.js";
-import { logger } from "./globalLogger.js";
-
-const execAsync = promisify(exec);
-
-interface ParsedMarkdownFile {
-  content: string;
-  config?: CustomSlashCommandConfig;
-}
-
-/**
- * Parse YAML frontmatter from markdown content
- */
-export function parseFrontmatter(content: string): {
-  frontmatter?: Record<string, unknown>;
-  content: string;
-} {
-  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
-  const match = content.match(frontmatterRegex);
-
-  if (!match) {
-    return { content };
-  }
-
-  const [, frontmatterStr, bodyContent] = match;
-
-  try {
-    // Simple YAML parser for our use case (supports key: value and list items)
-    const frontmatter: Record<string, unknown> = {};
-    const lines = frontmatterStr.split("\n");
-    let currentKey: string | null = null;
-
-    for (const line of lines) {
-      const trimmedLine = line.trim();
-      if (!trimmedLine || trimmedLine.startsWith("#")) continue;
-
-      // Check if it's a list item
-      if (trimmedLine.startsWith("-") && currentKey) {
-        let value = trimmedLine.slice(1).trim();
-        if (value) {
-          // Remove surrounding quotes if present
-          if (
-            (value.startsWith('"') && value.endsWith('"')) ||
-            (value.startsWith("'") && value.endsWith("'"))
-          ) {
-            value = value.slice(1, -1);
-          }
-          if (!Array.isArray(frontmatter[currentKey])) {
-            frontmatter[currentKey] = [];
-          }
-          (frontmatter[currentKey] as unknown[]).push(value);
-        }
-        continue;
-      }
-
-      const colonIndex = trimmedLine.indexOf(":");
-      if (colonIndex === -1) continue;
-
-      const key = trimmedLine.slice(0, colonIndex).trim();
-      const value = trimmedLine.slice(colonIndex + 1).trim();
-
-      currentKey = key;
-      if (value) {
-        // Remove surrounding quotes if present
-        const unquotedValue =
-          (value.startsWith('"') && value.endsWith('"')) ||
-          (value.startsWith("'") && value.endsWith("'"))
-            ? value.slice(1, -1)
-            : value;
-        frontmatter[key] = unquotedValue;
-      }
-    }
-
-    return { frontmatter, content: bodyContent };
-  } catch {
-    // If parsing fails, just return the content without frontmatter
-    return { content };
-  }
-}
-
-/**
- * Parse markdown file and extract config and content
- */
-export function parseMarkdownFile(filePath: string): ParsedMarkdownFile {
-  try {
-    const fileContent = readFileSync(filePath, "utf-8");
-    const { frontmatter, content } = parseFrontmatter(fileContent);
-
-    let config: CustomSlashCommandConfig | undefined;
-
-    if (frontmatter) {
-      config = {};
-
-      if (frontmatter.model && typeof frontmatter.model === "string") {
-        config.model = frontmatter.model;
-      }
-
-      if (
-        frontmatter.description &&
-        typeof frontmatter.description === "string"
-      ) {
-        config.description = frontmatter.description;
-      }
-
-      if (frontmatter["allowed-tools"]) {
-        if (Array.isArray(frontmatter["allowed-tools"])) {
-          config.allowedTools = frontmatter["allowed-tools"].filter(
-            (item): item is string => typeof item === "string",
-          );
-        } else if (typeof frontmatter["allowed-tools"] === "string") {
-          config.allowedTools = frontmatter["allowed-tools"]
-            .split(",")
-            .map((s) => s.trim())
-            .filter((s) => s.length > 0);
-        }
-      }
-    }
-
-    return {
-      content: content.trim(),
-      config,
-    };
-  } catch (error) {
-    throw new Error(
-      `Failed to parse markdown file ${filePath}: ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
-}
-
-/**
- * Parse and execute bash commands in markdown content
- */
-export interface BashCommandResult {
-  command: string;
-  output: string;
-  exitCode: number;
-}
-
-/**
- * Block syntax pattern: ```! command ```
- */
-const BLOCK_BASH_REGEX = /```!\s*\n?([\s\S]*?)\n?```/g;
-
-/**
- * Inline syntax pattern: !`command`
- */
-const INLINE_BASH_REGEX = /!`([^`]+)`/g;
-
-export function parseBashCommands(content: string): {
-  commands: string[];
-  processedContent: string;
-} {
-  // Performance gate: skip expensive regex if no bash pattern exists
-  // Covers the common case where 93% of skills have no bash substitution
-  if (!content.includes("!`") && !content.includes("```!")) {
-    return { commands: [], processedContent: content };
-  }
-
-  const commands: string[] = [];
-
-  // Extract block commands
-  let blockMatch;
-  const blockRegex = new RegExp(
-    BLOCK_BASH_REGEX.source,
-    BLOCK_BASH_REGEX.flags,
-  );
-  while ((blockMatch = blockRegex.exec(content)) !== null) {
-    const cmd = blockMatch[1].trim();
-    if (cmd) {
-      commands.push(cmd);
-    }
-  }
-
-  // Extract inline commands
-  let inlineMatch;
-  const inlineRegex = new RegExp(
-    INLINE_BASH_REGEX.source,
-    INLINE_BASH_REGEX.flags,
-  );
-  while ((inlineMatch = inlineRegex.exec(content)) !== null) {
-    const cmd = inlineMatch[1].trim();
-    if (cmd) {
-      commands.push(cmd);
-    }
-  }
-
-  // For now, return the content as-is. The actual command execution
-  // will be handled by the slash command manager
-  return {
-    commands,
-    processedContent: content,
-  };
-}
-
-/**
- * Truncate output if it exceeds the size limit.
- * Writes to a temp file and returns a preview + file path if truncated.
- */
-export function truncateOutput(output: string): string {
-  if (output.length <= SKILL_BASH_MAX_OUTPUT_CHARS) {
-    return output;
-  }
-
-  const preview = output.slice(0, PREVIEW_SIZE_BYTES);
-  const tempDir = join(tmpdir(), "wave-skill-bash");
-  mkdirSync(tempDir, { recursive: true });
-
-  const tempFile = join(
-    tempDir,
-    `output-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.txt`,
-  );
-  writeFileSync(tempFile, output, "utf-8");
-
-  return `${preview}\n\n[Output truncated (${output.length} chars). Full output saved to: ${tempFile}]`;
-}
-
-/**
- * Format a bash command result for inclusion in skill content.
- * Failed commands (non-zero exit code) are wrapped with an error indicator.
- */
-function formatBashResult(result: BashCommandResult): string {
-  const output = truncateOutput(result.output);
-  if (result.exitCode !== 0) {
-    return `<error>Command failed (exit code ${result.exitCode}): ${output}</error>`;
-  }
-  return output;
-}
-
-/**
- * Replace bash command placeholders with their outputs.
- * Uses function replacer to avoid $$, $&, $' corruption in shell output.
- * Handles both inline (!`cmd`) and block (```! cmd ```) syntax.
- */
-export function replaceBashCommandsWithOutput(
-  content: string,
-  results: BashCommandResult[],
-): string {
-  let processedContent = content;
-  let commandIndex = 0;
-
-  // Replace block syntax first: ```! command ```
-  processedContent = processedContent.replace(BLOCK_BASH_REGEX, () => {
-    if (commandIndex < results.length) {
-      const result = results[commandIndex++];
-      return formatBashResult(result);
-    }
-    return "";
-  });
-
-  // Replace inline syntax: !`command`
-  processedContent = processedContent.replace(INLINE_BASH_REGEX, () => {
-    if (commandIndex < results.length) {
-      const result = results[commandIndex++];
-      return formatBashResult(result);
-    }
-    return "";
-  });
-
-  return processedContent;
-}
-
-/**
- * Execute bash commands and return results
- */
-export async function executeBashCommands(
-  commands: string[],
-  workdir: string,
-  timeout: number = 30000,
-): Promise<BashCommandResult[]> {
-  const results: BashCommandResult[] = [];
-
-  for (const command of commands) {
-    try {
-      const { stdout, stderr } = await execAsync(command, {
-        cwd: workdir,
-        timeout,
-      });
-      results.push({
-        command,
-        output: (stdout + (stderr || "")).trim(),
-        exitCode: 0,
-      });
-    } catch (error: unknown) {
-      const execError = error as {
-        stdout?: string;
-        stderr?: string;
-        message?: string;
-        code?: number;
-      };
-      const errorOutput = (
-        (execError.stdout || "") +
-        (execError.stderr || "") +
-        (execError.message || "")
-      ).trim();
-      const exitCode = execError.code || 1;
-      logger?.warn(
-        `[Skill bash] Command failed (exit code ${exitCode}): ${command}\n${errorOutput}`,
-      );
-      results.push({
-        command,
-        output: errorOutput,
-        exitCode,
-      });
-    }
-  }
-
-  return results;
-}

package/src/utils/mcpUtils.ts

@@ -1,138 +0,0 @@
-import { ChatCompletionFunctionTool } from "openai/resources.js";
-import type { ToolPlugin, ToolResult, ToolContext } from "../tools/types.js";
-import type { McpTool, McpServerStatus } from "../types/index.js";
-import { processToolResult } from "./toolResultStorage.js";
-import { DEFAULT_MAX_RESULT_SIZE_CHARS } from "../constants/toolLimits.js";
-
-/**
- * Recursively clean schema to remove unsupported fields
- */
-function cleanSchema(schema: unknown): unknown {
-  if (typeof schema !== "object" || schema === null) {
-    return schema;
-  }
-
-  if (Array.isArray(schema)) {
-    return schema.map(cleanSchema);
-  }
-
-  const newSchema: Record<string, unknown> = {};
-  const obj = schema as Record<string, unknown>;
-
-  for (const key in obj) {
-    // Remove $schema as OpenAI API doesn't accept it
-    // Remove exclusiveMinimum/exclusiveMaximum as some models (e.g. Gemini) don't support them
-    if (
-      key === "$schema" ||
-      key === "exclusiveMinimum" ||
-      key === "exclusiveMaximum"
-    ) {
-      continue;
-    }
-
-    // Handle type as an array (e.g. ["string", "null"])
-    if (key === "type" && Array.isArray(obj[key])) {
-      const types = obj[key] as string[];
-      const nonNullTypes = types.filter((t) => t !== "null");
-      if (nonNullTypes.length > 0) {
-        newSchema["type"] = nonNullTypes[0];
-      }
-      if (types.includes("null")) {
-        newSchema["nullable"] = true;
-      }
-      continue;
-    }
-
-    newSchema[key] = cleanSchema(obj[key]);
-  }
-  return newSchema;
-}
-
-/**
- * Convert MCP tool to OpenAI function tool format
- */
-export function mcpToolToOpenAITool(
-  mcpTool: McpTool,
-  serverName: string,
-): ChatCompletionFunctionTool {
-  const cleanInputSchema = cleanSchema(mcpTool.inputSchema) as Record<
-    string,
-    unknown
-  >;
-
-  const prefixedName = `mcp__${serverName}__${mcpTool.name}`;
-
-  return {
-    type: "function",
-    function: {
-      name: prefixedName,
-      description: `${mcpTool.description || `Tool from MCP server ${serverName}`} (MCP: ${serverName})`,
-      parameters: cleanInputSchema,
-    },
-  };
-}
-
-/**
- * Create a tool plugin wrapper for an MCP tool
- */
-export function createMcpToolPlugin(
-  mcpTool: McpTool,
-  serverName: string,
-  executeTool: (
-    name: string,
-    args: Record<string, unknown>,
-    context?: ToolContext,
-  ) => Promise<{
-    success: boolean;
-    content: string;
-    serverName?: string;
-    images?: Array<{ data: string; mediaType?: string }>;
-  }>,
-): ToolPlugin {
-  const prefixedName = `mcp__${serverName}__${mcpTool.name}`;
-  return {
-    name: prefixedName,
-    config: mcpToolToOpenAITool(mcpTool, serverName),
-    async execute(
-      args: Record<string, unknown>,
-      context?: ToolContext,
-    ): Promise<ToolResult> {
-      try {
-        const result = await executeTool(prefixedName, args, context);
-
-        // Process content for size limits — only text content, not images
-        const processedContent = processToolResult(
-          result.content || `Executed ${mcpTool.name}`,
-          DEFAULT_MAX_RESULT_SIZE_CHARS,
-          `mcp_${serverName}_${mcpTool.name}`,
-        );
-
-        return {
-          success: true,
-          content: processedContent,
-          images: result.images,
-        };
-      } catch (error) {
-        return {
-          success: false,
-          content: "",
-          error: error instanceof Error ? error.message : String(error),
-        };
-      }
-    },
-  };
-}
-
-/**
- * Find which server a tool belongs to
- */
-export function findToolServer(
-  toolName: string,
-  servers: McpServerStatus[],
-): McpServerStatus | undefined {
-  return servers.find(
-    (s) =>
-      (s.status === "connected" || s.status === "reconnecting") &&
-      s.tools?.some((t) => t.name === toolName),
-  );
-}