bunosh 0.4.1 → 0.4.6

package/src/mcp-server.js

@@ -0,0 +1,575 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListToolsRequestSchema,
+  McpError,
+} from '@modelcontextprotocol/sdk/types.js';
+import { processCommands } from './program.js';
+
+// Global state for managing conversations and pending questions
+const conversations = new Map();
+
+/**
+ * Convert BunoshCommand objects to MCP tools
+ * @param {Array<BunoshCommand>} parsedCommands - Array of parsed BunoshCommand objects
+ * @returns {Object} MCP tools object
+ */
+function createMcpTools(parsedCommands) {
+  const tools = {};
+
+  parsedCommands.forEach((command) => {
+    // Create input schema for the tool
+    const properties = {};
+    const required = [];
+
+    // Add positional arguments
+    Object.entries(command.args).forEach(([argName, defaultValue]) => {
+      properties[argName] = {
+        type: 'string',
+        description: `Argument: ${argName}`,
+      };
+      if (defaultValue === undefined) {
+        required.push(argName);
+      }
+    });
+
+    // Add options
+    Object.entries(command.opts).forEach(([optName, defaultValue]) => {
+      properties[optName] = {
+        type: typeof defaultValue === 'boolean' ? 'boolean' : 'string',
+        description: `Option: --${optName}`,
+      };
+      // Don't make options required as they have defaults
+    });
+
+    tools[command.fullName] = {
+      name: command.fullName,
+      description: command.comment || `Bunosh command: ${command.fullName}`,
+      inputSchema: {
+        type: 'object',
+        properties,
+        required: required.length > 0 ? required : undefined,
+      },
+    };
+  });
+
+  // Add the answer tool for handling interactive questions
+  tools.answer = {
+    name: 'answer',
+    description: 'Provide an answer to a question asked by a Bunosh command',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        conversationId: {
+          type: 'string',
+          description: 'The ID of the conversation to answer',
+        },
+        questionId: {
+          type: 'string',
+          description: 'The ID of the question to answer',
+        },
+        answer: {
+          oneOf: [
+            { type: 'string' },
+            { type: 'boolean' },
+            { type: 'array', items: { type: 'string' } }
+          ],
+          description: 'The answer to provide - can be string, boolean, or array of strings for multiple choice',
+        }
+      },
+      required: ['conversationId', 'questionId', 'answer'],
+    },
+  };
+
+  return tools;
+}
+
+/**
+ * Create a conversation state for tracking multi-question interactions
+ * @param {string} conversationId - Unique conversation identifier
+ * @param {BunoshCommand} command - The command being executed
+ * @param {Object} args - Command arguments
+ * @returns {Object} Conversation state object
+ */
+function createConversation(conversationId, command, args) {
+  const conversation = {
+    id: conversationId,
+    command,
+    args,
+    questions: [], // List of questions asked in this conversation
+    answers: {},  // Map of questionId to answer
+    currentQuestion: null,
+    output: [],
+    isComplete: false,
+    result: null,
+    startTime: Date.now()
+  };
+
+  conversations.set(conversationId, conversation);
+  return conversation;
+}
+
+/**
+ * Create an interactive ask function that works with conversation state
+ * @param {Object} conversation - The conversation state
+ * @returns {Function} Interactive ask function
+ */
+function createConversationAskFunction(conversation) {
+  return async (question, defaultValueOrOptions = {}, options = {}) => {
+    // Check if we already have an answer for this exact question text
+    // Look for ANY question with the same text that has an answer
+    // Important: Use 'in' operator to check if key exists, even if the value is falsy (like false)
+    const existingQuestionWithAnswer = conversation.questions.find(q => q.message === question && q.id in conversation.answers);
+
+    if (existingQuestionWithAnswer) {
+      return conversation.answers[existingQuestionWithAnswer.id];
+    }
+
+    // Generate a unique question ID
+    const questionId = `q_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+    // Parse the question options to understand what type of answer is expected
+    let questionOptions = {};
+    let expectedType = 'string';
+
+    // Smart parameter detection (copied from original ask function)
+    if (defaultValueOrOptions !== null && typeof defaultValueOrOptions !== 'object') {
+      questionOptions.default = defaultValueOrOptions;
+      questionOptions = { ...questionOptions, ...options };
+
+      if (typeof defaultValueOrOptions === 'boolean') {
+        expectedType = 'boolean';
+      }
+    } else if (Array.isArray(defaultValueOrOptions)) {
+      questionOptions.choices = defaultValueOrOptions;
+      questionOptions = { ...questionOptions, ...options };
+      expectedType = 'choices';
+    } else {
+      questionOptions = { ...defaultValueOrOptions, ...options };
+      if (questionOptions.type === 'confirm') {
+        expectedType = 'boolean';
+      } else if (questionOptions.choices) {
+        expectedType = 'choices';
+      }
+    }
+
+    // Store the question data
+    const questionData = {
+      id: questionId,
+      conversationId: conversation.id,
+      message: question,
+      options: questionOptions,
+      expectedType,
+      choices: questionOptions.choices || null,
+      multiple: questionOptions.multiple || false,
+      timestamp: Date.now()
+    };
+
+    // Add question to conversation (only if it's not already there)
+    // Check if this exact question already exists
+    const existingQuestion = conversation.questions.find(q => q.message === question);
+    if (!existingQuestion) {
+      conversation.questions.push(questionData);
+      conversation.currentQuestion = questionData;
+    } else {
+      conversation.currentQuestion = existingQuestion;
+    }
+
+    // Throw a special error to signal the MCP server that a question needs to be answered
+    const questionError = new Error(`INTERACTIVE_QUESTION:${JSON.stringify(questionData)}`);
+    questionError.code = 'INTERACTIVE_QUESTION';
+    throw questionError;
+  };
+}
+
+/**
+ * Execute a Bunosh command with conversation-based multi-question support
+ * @param {BunoshCommand} command - Parsed BunoshCommand object
+ * @param {Object} args - Arguments from MCP tool call
+ * @param {string} [conversationId] - ID for resuming an existing conversation
+ * @returns {Promise<string>} Command output with task information
+ */
+async function executeBunoshCommand(command, args, conversationId = null) {
+  // Import task functions to access executed tasks
+  const { tasksExecuted } = await import('./task.js');
+
+  // Check if we're resuming an existing conversation
+  if (conversationId && conversations.has(conversationId)) {
+    const conversation = conversations.get(conversationId);
+
+    // Re-execute the command with the same conversation state
+    // The ask function will return pre-provided answers for already-answered questions
+    return executeCommandWithConversation(conversation);
+  }
+
+  // Create new conversation
+  const newConversationId = conversationId || `conv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  const conversation = createConversation(newConversationId, command, args);
+
+  return executeCommandWithConversation(conversation);
+}
+
+/**
+ * Execute a command within a conversation context
+ * @param {Object} conversation - The conversation state
+ * @returns {Promise<string>} Command output or next question
+ */
+async function executeCommandWithConversation(conversation) {
+  // Import task functions to access executed tasks
+  const { tasksExecuted } = await import('./task.js');
+
+  // Capture stdout/stderr
+  const originalConsoleLog = console.log;
+  const originalConsoleError = console.error;
+  const output = [];
+
+  console.log = (...consoleArgs) => {
+    const message = consoleArgs.join(' ');
+    output.push(message);
+    conversation.output.push(message);
+  };
+
+  console.error = (...consoleArgs) => {
+    const message = `Error: ${consoleArgs.join(' ')}`;
+    output.push(message);
+    conversation.output.push(message);
+  };
+
+  try {
+    // Set up conversation-based ask function
+    globalThis._mcpAskFunction = createConversationAskFunction(conversation);
+
+    // Build arguments array using the parsed command information
+    const cmdArgs = [];
+    const optionsObject = {};
+
+    // Add positional arguments
+    Object.keys(conversation.command.args).forEach((argName) => {
+      if (conversation.args[argName] !== undefined) {
+        cmdArgs.push(conversation.args[argName]);
+      } else {
+        // Use default value from parsed command
+        cmdArgs.push(conversation.command.args[argName]);
+      }
+    });
+
+    // Handle options object
+    const optionKeys = Object.keys(conversation.command.opts);
+    if (optionKeys.length > 0) {
+      optionKeys.forEach((optName) => {
+        if (conversation.args[optName] !== undefined) {
+          optionsObject[optName] = conversation.args[optName];
+        } else {
+          // Use default value from parsed command
+          optionsObject[optName] = conversation.command.opts[optName];
+        }
+      });
+      cmdArgs.push(optionsObject);
+    }
+
+    // Execute the command
+    const result = await conversation.command.function(...cmdArgs);
+
+    // Mark conversation as complete
+    conversation.isComplete = true;
+    conversation.result = result;
+
+    // Restore console and cleanup
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+    delete globalThis._mcpAskFunction;
+
+    // Get tasks executed during this command
+    const executedTasks = tasksExecuted.filter(task =>
+      task.startTime && task.startTime >= conversation.startTime
+    );
+
+    // Format response with task information
+    const response = {
+      output: output.join('\n'),
+      result: result,
+      tasks: executedTasks.map(task => ({
+        name: task.name,
+        status: task.status,
+        duration: task.duration,
+        output: task.result?.output || null
+      }))
+    };
+
+    // Add direct output if result is a string
+    if (result && typeof result === 'string') {
+      response.output += (response.output ? '\n' : '') + result;
+    }
+
+    // Clean up completed conversation
+    conversations.delete(conversation.id);
+
+    // If no tasks were tracked, still return the output
+    if (executedTasks.length === 0) {
+      return response.output || 'Command executed successfully';
+    }
+
+    // Return JSON response with task information
+    return JSON.stringify(response, null, 2);
+  } catch (error) {
+    // Check if this is an interactive question
+    if (error.code === 'INTERACTIVE_QUESTION') {
+      // Extract question data from error message
+      const questionData = JSON.parse(error.message.split('INTERACTIVE_QUESTION:')[1]);
+
+      // Format the question for the AI to answer
+      let questionPrompt = `❓ **Question:** ${questionData.message}\n\n`;
+
+      if (questionData.expectedType === 'boolean') {
+        questionPrompt += `Please provide a boolean answer (true/false).`;
+      } else if (questionData.expectedType === 'choices') {
+        if (questionData.multiple) {
+          questionPrompt += `Please select one or more choices from: ${questionData.choices.join(', ')}\n`;
+          questionPrompt += `Provide the answer as an array of strings, e.g., ["option1", "option2"]`;
+        } else {
+          questionPrompt += `Please choose one option from: ${questionData.choices.join(', ')}\n`;
+          questionPrompt += `Provide the answer as a string (the exact choice).`;
+        }
+      } else {
+        questionPrompt += `Please provide a string answer.`;
+        if (questionData.options.default !== undefined) {
+          questionPrompt += ` Default value: ${questionData.options.default}`;
+        }
+      }
+
+      questionPrompt += `\n\nUse the \`answer\` tool to respond with:\n`;
+      questionPrompt += `- conversationId: "${questionData.conversationId}"\n`;
+      questionPrompt += `- questionId: "${questionData.id}"\n`;
+      questionPrompt += `- answer: <your answer>`;
+
+      // Restore console and cleanup for now
+      console.log = originalConsoleLog;
+      console.error = originalConsoleError;
+      delete globalThis._mcpAskFunction;
+
+      // Return special response that prompts the AI to use the answer tool
+      return JSON.stringify({
+        interactive: true,
+        conversationId: questionData.conversationId,
+        questionId: questionData.id,
+        question: questionData.message,
+        prompt: questionPrompt,
+        expectedType: questionData.expectedType,
+        choices: questionData.choices,
+        multiple: questionData.multiple,
+        default: questionData.options.default,
+        progress: `Question ${conversation.questions.length} of ${conversation.questions.length + 1}`
+      }, null, 2);
+    }
+
+    // Handle other errors
+    conversation.error = error;
+
+    // Get tasks executed before the error
+    const executedTasks = tasksExecuted.filter(task =>
+      task.startTime && task.startTime >= conversation.startTime
+    );
+
+    // Format error response with task information
+    const errorResponse = {
+      output: output.join('\n'),
+      error: error.message,
+      tasks: executedTasks.map(task => ({
+        name: task.name,
+        status: task.status,
+        duration: task.duration,
+        output: task.result?.output || null
+      }))
+    };
+
+    // Clean up conversation state
+    conversations.delete(conversation.id);
+
+    throw new Error(`Command execution failed: ${error.message}\n${JSON.stringify(errorResponse, null, 2)}`);
+  }
+}
+
+/**
+ * Handle the answer tool for responding to interactive questions
+ * @param {Object} args - Tool arguments containing conversationId, questionId, and answer
+ * @returns {Object} MCP response
+ */
+function handleAnswerTool(args) {
+  const { conversationId, questionId, answer } = args;
+
+  if (!conversationId || !questionId) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      'Missing required parameters: conversationId and questionId'
+    );
+  }
+
+  const conversation = conversations.get(conversationId);
+  if (!conversation) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `No conversation found with ID: ${conversationId}`
+    );
+  }
+
+  // Validate the answer based on question expectations
+  let validatedAnswer = answer;
+  const question = conversation.questions.find(q => q.id === questionId);
+
+  if (!question) {
+    throw new McpError(
+      ErrorCode.InvalidParams,
+      `No question found with ID: ${questionId} in conversation: ${conversationId}`
+    );
+  }
+
+  if (question.choices && Array.isArray(answer)) {
+    // For multiple choice questions, validate that all choices are valid
+    const invalidChoices = answer.filter(choice => !question.choices.includes(choice));
+    if (invalidChoices.length > 0) {
+      throw new McpError(
+        ErrorCode.InvalidParams,
+        `Invalid choices: ${invalidChoices.join(', ')}. Valid choices are: ${question.choices.join(', ')}`
+      );
+    }
+  }
+
+  // Store the answer
+  conversation.answers[questionId] = validatedAnswer;
+
+  return {
+    content: [
+      {
+        type: 'text',
+        text: `Answer received for question: ${question.message}`,
+      },
+    ],
+  };
+}
+
+/**
+ * Continue a conversation after receiving an answer
+ * @param {string} conversationId - The conversation ID to continue
+ * @returns {Promise<string>} Command output or next question
+ */
+async function continueConversation(conversationId) {
+  const conversation = conversations.get(conversationId);
+  if (!conversation) {
+    throw new Error(`No conversation found with ID: ${conversationId}`);
+  }
+
+  // Execute the command again, but this time it will use pre-provided answers
+  return executeCommandWithConversation(conversation);
+}
+
+/**
+ * Create MCP server from Bunosh commands
+ * @param {Object} commands - Commands object from Bunoshfile
+ * @param {Object} sources - Sources object containing comments and metadata
+ * @returns {Server} Configured MCP server
+ */
+export function createMcpServer(commands, sources) {
+  const server = new Server(
+    {
+      name: 'bunosh',
+      version: '0.1.5',
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  // Process commands using the existing logic from program.js
+  const parsedCommands = processCommands(commands, sources);
+  const tools = createMcpTools(parsedCommands);
+
+  // Create a map for quick command lookup
+  const commandMap = new Map(parsedCommands.map(cmd => [cmd.fullName, cmd]));
+
+  // List tools handler
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: Object.values(tools),
+    };
+  });
+
+  // Call tool handler
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    // Handle the answer tool separately
+    if (name === 'answer') {
+      const result = handleAnswerTool(args);
+
+      // After providing an answer, try to continue the conversation
+      const { conversationId } = args;
+      if (conversationId) {
+        try {
+          const continuationResult = await continueConversation(conversationId);
+          return {
+            content: [
+              result.content[0], // The "Answer received" message
+              {
+                type: 'text',
+                text: continuationResult,
+              },
+            ],
+          };
+        } catch (error) {
+          // If continuation fails, just return the answer confirmation
+          return result;
+        }
+      }
+
+      return result;
+    }
+
+    const command = commandMap.get(name);
+    if (!command) {
+      throw new McpError(
+        ErrorCode.MethodNotFound,
+        `Unknown command: ${name}`
+      );
+    }
+
+    try {
+      // Check if this is a continuation of a previous conversation
+      const conversationId = args.conversationId;
+
+      // Execute the Bunosh command with provided arguments
+      const result = await executeBunoshCommand(command, args, conversationId);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: result,
+          },
+        ],
+      };
+    } catch (error) {
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Error executing command ${name}: ${error.message}`
+      );
+    }
+  });
+
+  return server;
+}
+
+/**
+ * Start MCP server with stdio transport
+ * @param {Server} server - MCP server instance
+ */
+export async function startMcpServer(server) {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  // Server is now running and listening for MCP protocol messages
+  // No need to return anything as it will handle communication via stdio
+}

package/src/printer.js

@@ -93,7 +93,7 @@ export class Printer {
 
     // Add task prefix for parallel tasks on output lines
     const prefix = this.taskId ? getTaskPrefix(this.taskId) : '';
-    const prefixedLine = prefix ? `${chalk.gray.dim(prefix)} ${line}` : line;
+    const prefixedLine = prefix ? `${prefix} ${line}` : line;
 
     const formattedLine = this.formatter.formatOutput(prefixedLine, isError);
     if (formattedLine) {