@nils.del/supergrok 1.0.0

package/src/mcp/transports.ts

@@ -0,0 +1,142 @@
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+export type TransportType = 'stdio' | 'http' | 'sse';
+
+export interface StdioTransportConfig {
+  type: 'stdio';
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface HttpTransportConfig {
+  type: 'http';
+  url: string;
+}
+
+export interface SSETransportConfig {
+  type: 'sse';
+  url: string;
+}
+
+export type TransportConfig = StdioTransportConfig | HttpTransportConfig | SSETransportConfig;
+
+export interface MCPTransport {
+  connect(): Promise<Transport>;
+  disconnect(): Promise<void>;
+  getType(): TransportType;
+}
+
+class StdioMCPTransport implements MCPTransport {
+  private config: StdioTransportConfig;
+  private transport: StdioClientTransport | null = null;
+
+  constructor(config: StdioTransportConfig) {
+    this.config = config;
+  }
+
+  async connect(): Promise<Transport> {
+    const env: Record<string, string> = {};
+
+    // Copy process.env, filtering out undefined values
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== undefined) {
+        env[key] = value;
+      }
+    }
+
+    // Merge with config env
+    if (this.config.env) {
+      Object.assign(env, this.config.env);
+    }
+
+    this.transport = new StdioClientTransport({
+      command: this.config.command,
+      args: this.config.args || [],
+      env
+    });
+
+    return this.transport;
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.transport) {
+      await this.transport.close();
+      this.transport = null;
+    }
+  }
+
+  getType(): TransportType {
+    return 'stdio';
+  }
+}
+
+class HttpMCPTransport implements MCPTransport {
+  private config: HttpTransportConfig;
+  private transport: StreamableHTTPClientTransport | null = null;
+
+  constructor(config: HttpTransportConfig) {
+    this.config = config;
+  }
+
+  async connect(): Promise<Transport> {
+    this.transport = new StreamableHTTPClientTransport(
+      new URL(this.config.url)
+    );
+    return this.transport;
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.transport) {
+      await this.transport.close();
+      this.transport = null;
+    }
+  }
+
+  getType(): TransportType {
+    return 'http';
+  }
+}
+
+class SSEMCPTransport implements MCPTransport {
+  private config: SSETransportConfig;
+  private transport: SSEClientTransport | null = null;
+
+  constructor(config: SSETransportConfig) {
+    this.config = config;
+  }
+
+  async connect(): Promise<Transport> {
+    this.transport = new SSEClientTransport(
+      new URL(this.config.url)
+    );
+    return this.transport;
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.transport) {
+      await this.transport.close();
+      this.transport = null;
+    }
+  }
+
+  getType(): TransportType {
+    return 'sse';
+  }
+}
+
+export function createTransport(config: TransportConfig): MCPTransport {
+  switch (config.type) {
+    case 'stdio':
+      return new StdioMCPTransport(config);
+    case 'http':
+      return new HttpMCPTransport(config);
+    case 'sse':
+      return new SSEMCPTransport(config);
+    default:
+      throw new Error(`Unknown transport type: ${(config as any).type}`);
+  }
+}

package/src/tools/bash.ts

@@ -0,0 +1,84 @@
+import { spawn } from 'child_process';
+import { ToolResult } from './types.js';
+
+export interface BashToolArgs {
+  command: string;
+  timeout?: number;
+}
+
+export async function executeBashCommand(args: BashToolArgs): Promise<ToolResult> {
+  const { command, timeout = 120000 } = args;
+
+  return new Promise((resolve) => {
+    const childProcess = spawn('bash', ['-c', command], {
+      cwd: process.cwd(),
+      env: process.env,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    const timer = setTimeout(() => {
+      childProcess.kill('SIGTERM');
+      resolve({
+        success: false,
+        error: `Command timed out after ${timeout}ms`
+      });
+    }, timeout);
+
+    childProcess.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    childProcess.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    childProcess.on('close', (code) => {
+      clearTimeout(timer);
+
+      if (code === 0) {
+        resolve({
+          success: true,
+          output: stdout.trim() || stderr.trim() || 'Command completed successfully'
+        });
+      } else {
+        resolve({
+          success: false,
+          error: stderr.trim() || stdout.trim() || `Command failed with exit code ${code}`
+        });
+      }
+    });
+
+    childProcess.on('error', (error) => {
+      clearTimeout(timer);
+      resolve({
+        success: false,
+        error: `Failed to execute command: ${error.message}`
+      });
+    });
+  });
+}
+
+export const bashToolDefinition = {
+  type: "function" as const,
+  function: {
+    name: "bash",
+    description: "Execute a bash command and return the output. Use this for running shell commands, file operations, git commands, etc.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The bash command to execute"
+        },
+        timeout: {
+          type: "number",
+          description: "Optional timeout in milliseconds (default: 120000)"
+        }
+      },
+      required: ["command"]
+    }
+  }
+};

package/src/tools/index.ts

@@ -0,0 +1,91 @@
+import { ToolResult, ToolCall } from './types.js';
+import { executeBashCommand, bashToolDefinition } from './bash.js';
+import { viewFile, createFile, strReplace, insertText, textEditorToolDefinition } from './text-editor.js';
+import { getMCPManager } from '../mcp/client.js';
+
+export { ToolResult, ToolCall };
+
+export function getBuiltInTools() {
+  return [bashToolDefinition, textEditorToolDefinition];
+}
+
+export async function getAllTools() {
+  const builtInTools = getBuiltInTools();
+  const mcpManager = getMCPManager();
+
+  // Ensure MCP servers are initialized
+  await mcpManager.ensureServersInitialized();
+
+  const mcpTools = mcpManager.getTools().map(tool => ({
+    type: "function" as const,
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }
+  }));
+
+  return [...builtInTools, ...mcpTools];
+}
+
+export async function executeToolCall(toolCall: ToolCall): Promise<ToolResult> {
+  const { function: fn } = toolCall;
+  const args = JSON.parse(fn.arguments || '{}');
+
+  // Handle MCP tools
+  if (fn.name.startsWith('mcp__')) {
+    try {
+      const mcpManager = getMCPManager();
+      const result = await mcpManager.callTool(fn.name, args);
+
+      // Convert MCP result to our format
+      const content = result.content
+        .map((c: any) => {
+          if (c.type === 'text') return c.text;
+          if (c.type === 'image') return `[Image: ${c.mimeType}]`;
+          return JSON.stringify(c);
+        })
+        .join('\n');
+
+      return {
+        success: !result.isError,
+        output: result.isError ? undefined : content,
+        error: result.isError ? content : undefined
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: `MCP tool error: ${error.message}`
+      };
+    }
+  }
+
+  // Handle built-in tools
+  switch (fn.name) {
+    case 'bash':
+      return await executeBashCommand(args);
+
+    case 'str_replace_editor':
+      switch (args.command) {
+        case 'view':
+          return await viewFile({ path: args.path, view_range: args.view_range });
+        case 'create':
+          return await createFile({ path: args.path, file_text: args.file_text });
+        case 'str_replace':
+          return await strReplace({ path: args.path, old_str: args.old_str, new_str: args.new_str });
+        case 'insert':
+          return await insertText({ path: args.path, insert_line: args.insert_line, new_str: args.new_str });
+        default:
+          return {
+            success: false,
+            error: `Unknown editor command: ${args.command}`
+          };
+      }
+
+    default:
+      return {
+        success: false,
+        error: `Unknown tool: ${fn.name}`
+      };
+  }
+}

package/src/tools/text-editor.ts

@@ -0,0 +1,222 @@
+import fs from 'fs';
+import path from 'path';
+import { ToolResult } from './types.js';
+
+export interface ViewArgs {
+  path: string;
+  view_range?: [number, number];
+}
+
+export interface CreateArgs {
+  path: string;
+  file_text: string;
+}
+
+export interface StrReplaceArgs {
+  path: string;
+  old_str: string;
+  new_str: string;
+}
+
+export interface InsertArgs {
+  path: string;
+  insert_line: number;
+  new_str: string;
+}
+
+export async function viewFile(args: ViewArgs): Promise<ToolResult> {
+  try {
+    const filePath = path.resolve(process.cwd(), args.path);
+
+    if (!fs.existsSync(filePath)) {
+      return {
+        success: false,
+        error: `File not found: ${args.path}`
+      };
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+
+    if (args.view_range) {
+      const [start, end] = args.view_range;
+      const startIdx = Math.max(0, start - 1);
+      const endIdx = Math.min(lines.length, end);
+
+      const numberedLines = lines
+        .slice(startIdx, endIdx)
+        .map((line, i) => `${startIdx + i + 1}: ${line}`)
+        .join('\n');
+
+      return {
+        success: true,
+        output: `File: ${args.path} (lines ${start}-${end})\n\n${numberedLines}`
+      };
+    }
+
+    const numberedLines = lines
+      .map((line, i) => `${i + 1}: ${line}`)
+      .join('\n');
+
+    return {
+      success: true,
+      output: `File: ${args.path} (${lines.length} lines)\n\n${numberedLines}`
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: `Failed to read file: ${error.message}`
+    };
+  }
+}
+
+export async function createFile(args: CreateArgs): Promise<ToolResult> {
+  try {
+    const filePath = path.resolve(process.cwd(), args.path);
+    const dir = path.dirname(filePath);
+
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    fs.writeFileSync(filePath, args.file_text);
+
+    return {
+      success: true,
+      output: `File created successfully: ${args.path}`
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: `Failed to create file: ${error.message}`
+    };
+  }
+}
+
+export async function strReplace(args: StrReplaceArgs): Promise<ToolResult> {
+  try {
+    const filePath = path.resolve(process.cwd(), args.path);
+
+    if (!fs.existsSync(filePath)) {
+      return {
+        success: false,
+        error: `File not found: ${args.path}`
+      };
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+
+    if (!content.includes(args.old_str)) {
+      return {
+        success: false,
+        error: `String not found in file: "${args.old_str.substring(0, 50)}..."`
+      };
+    }
+
+    const occurrences = content.split(args.old_str).length - 1;
+    if (occurrences > 1) {
+      return {
+        success: false,
+        error: `Found ${occurrences} occurrences of the string. Please provide a more specific string to replace.`
+      };
+    }
+
+    const newContent = content.replace(args.old_str, args.new_str);
+    fs.writeFileSync(filePath, newContent);
+
+    return {
+      success: true,
+      output: `Successfully replaced text in ${args.path}`
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: `Failed to replace text: ${error.message}`
+    };
+  }
+}
+
+export async function insertText(args: InsertArgs): Promise<ToolResult> {
+  try {
+    const filePath = path.resolve(process.cwd(), args.path);
+
+    if (!fs.existsSync(filePath)) {
+      return {
+        success: false,
+        error: `File not found: ${args.path}`
+      };
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+
+    if (args.insert_line < 0 || args.insert_line > lines.length) {
+      return {
+        success: false,
+        error: `Invalid line number: ${args.insert_line}. File has ${lines.length} lines.`
+      };
+    }
+
+    lines.splice(args.insert_line, 0, args.new_str);
+    const newContent = lines.join('\n');
+    fs.writeFileSync(filePath, newContent);
+
+    return {
+      success: true,
+      output: `Successfully inserted text at line ${args.insert_line} in ${args.path}`
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: `Failed to insert text: ${error.message}`
+    };
+  }
+}
+
+export const textEditorToolDefinition = {
+  type: "function" as const,
+  function: {
+    name: "str_replace_editor",
+    description: `A powerful text editor tool for viewing and modifying files. Commands:
+- view: View file contents with line numbers
+- create: Create a new file with specified content
+- str_replace: Replace a specific string in a file (must be unique)
+- insert: Insert text at a specific line number`,
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          enum: ["view", "create", "str_replace", "insert"],
+          description: "The editing command to execute"
+        },
+        path: {
+          type: "string",
+          description: "The file path to operate on"
+        },
+        file_text: {
+          type: "string",
+          description: "For create command: the content of the new file"
+        },
+        old_str: {
+          type: "string",
+          description: "For str_replace command: the exact string to replace"
+        },
+        new_str: {
+          type: "string",
+          description: "For str_replace/insert commands: the new string to insert"
+        },
+        insert_line: {
+          type: "number",
+          description: "For insert command: the line number to insert at (0-indexed)"
+        },
+        view_range: {
+          type: "array",
+          items: { type: "number" },
+          description: "For view command: optional [start, end] line range"
+        }
+      },
+      required: ["command", "path"]
+    }
+  }
+};

package/src/tools/types.ts

@@ -0,0 +1,14 @@
+export interface ToolResult {
+  success: boolean;
+  output?: string;
+  error?: string;
+}
+
+export interface ToolCall {
+  id: string;
+  type: string;
+  function: {
+    name: string;
+    arguments: string;
+  };
+}