ropilot 0.1.2

package/README.md

@@ -0,0 +1,76 @@
+# Ropilot CLI
+
+AI-powered Roblox development assistant - MCP CLI wrapper.
+
+## Installation
+
+```bash
+# Run directly with npx (recommended)
+npx ropilot init
+
+# Or install globally
+npm install -g ropilot
+```
+
+## Quick Start
+
+1. **Initialize Ropilot in your project:**
+   ```bash
+   npx ropilot init
+   ```
+   This will:
+   - Prompt for your API key (get one at https://ropilot.ai)
+   - Download the latest agent prompts and configs
+   - Set up `.claude/` directory with subagent definitions
+
+2. **Add to your AI IDE:**
+
+   **Claude Desktop** - Add to `claude_desktop_config.json`:
+   ```json
+   {
+     "mcpServers": {
+       "ropilot": {
+         "command": "npx",
+         "args": ["ropilot"]
+       }
+     }
+   }
+   ```
+
+   **Or use HTTP directly:**
+   ```
+   https://ropilot.ai/ropilot/mcp/YOUR_API_KEY/message
+   ```
+
+3. **Make sure Roblox Studio is running** with the Ropilot plugin installed.
+
+## Commands
+
+```bash
+npx ropilot init [key]  # Set up Ropilot in current project
+npx ropilot             # Run as stdio MCP server
+npx ropilot config      # Show current configuration
+npx ropilot update      # Update prompts to latest version
+```
+
+## How It Works
+
+The CLI acts as a thin wrapper around the Ropilot edge server:
+
+1. **On `init`**: Downloads agent prompts and configs from the edge server, sets up your project
+2. **On `serve`** (default): Runs as a stdio MCP server, proxying all requests to the edge server
+
+## Configuration
+
+Global config is stored in `~/.ropilot/config.json`.
+
+Project-specific config can be added in `.ropilot.json`:
+```json
+{
+  "apiKey": "ropilot_..."
+}
+```
+
+## Links
+
+- Website: https://ropilot.ai

package/bin/ropilot.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+/**
+ * Ropilot CLI
+ *
+ * Commands:
+ *   ropilot init [key]  - Set up Ropilot in current project (downloads prompts, creates configs)
+ *   ropilot             - Run as stdio MCP server (proxies to edge)
+ *   ropilot config      - Show current configuration
+ *   ropilot update      - Update prompts and configs to latest version
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const libDir = join(__dirname, '..', 'lib');
+
+// Parse command line args
+const args = process.argv.slice(2);
+const command = args[0] || 'serve';
+
+async function main() {
+  switch (command) {
+    case 'init': {
+      const { init } = await import(join(libDir, 'setup.js'));
+      const apiKey = args[1] || null;
+      await init(apiKey);
+      break;
+    }
+
+    case 'update': {
+      const { update } = await import(join(libDir, 'setup.js'));
+      await update();
+      break;
+    }
+
+    case 'config': {
+      const { showConfig } = await import(join(libDir, 'config.js'));
+      await showConfig();
+      break;
+    }
+
+    case 'serve':
+    default: {
+      // If first arg looks like a command but isn't recognized, show help
+      if (command && !command.startsWith('-') && !['serve', 'init', 'update', 'config'].includes(command)) {
+        console.error(`Unknown command: ${command}`);
+        console.error('');
+        console.error('Usage:');
+        console.error('  ropilot init [key]  - Set up Ropilot in current project');
+        console.error('  ropilot             - Run as stdio MCP server');
+        console.error('  ropilot config      - Show current configuration');
+        console.error('  ropilot update      - Update prompts to latest version');
+        process.exit(1);
+      }
+
+      const { serve } = await import(join(libDir, 'proxy.js'));
+      await serve();
+      break;
+    }
+  }
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/lib/config.js

@@ -0,0 +1,119 @@
+/**
+ * Configuration management for Ropilot CLI
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// Global config directory (~/.ropilot/)
+const GLOBAL_CONFIG_DIR = join(homedir(), '.ropilot');
+const GLOBAL_CONFIG_FILE = join(GLOBAL_CONFIG_DIR, 'config.json');
+
+// Project-level config file
+const PROJECT_CONFIG_FILE = '.ropilot.json';
+
+// Edge server base URL
+export const EDGE_URL = 'https://ropilot.ai/ropilot';
+
+// Default config
+const DEFAULT_CONFIG = {
+  apiKey: null,
+  promptsVersion: null,
+  lastUpdated: null
+};
+
+/**
+ * Ensure global config directory exists
+ */
+export function ensureConfigDir() {
+  if (!existsSync(GLOBAL_CONFIG_DIR)) {
+    mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Load global config
+ */
+export function loadGlobalConfig() {
+  ensureConfigDir();
+
+  if (existsSync(GLOBAL_CONFIG_FILE)) {
+    try {
+      return JSON.parse(readFileSync(GLOBAL_CONFIG_FILE, 'utf-8'));
+    } catch (e) {
+      return { ...DEFAULT_CONFIG };
+    }
+  }
+
+  return { ...DEFAULT_CONFIG };
+}
+
+/**
+ * Save global config
+ */
+export function saveGlobalConfig(config) {
+  ensureConfigDir();
+  writeFileSync(GLOBAL_CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Load project config (if exists)
+ */
+export function loadProjectConfig() {
+  if (existsSync(PROJECT_CONFIG_FILE)) {
+    try {
+      return JSON.parse(readFileSync(PROJECT_CONFIG_FILE, 'utf-8'));
+    } catch (e) {
+      return null;
+    }
+  }
+  return null;
+}
+
+/**
+ * Get the API key (project config overrides global)
+ */
+export function getApiKey() {
+  const projectConfig = loadProjectConfig();
+  if (projectConfig?.apiKey) {
+    return projectConfig.apiKey;
+  }
+
+  const globalConfig = loadGlobalConfig();
+  return globalConfig.apiKey;
+}
+
+/**
+ * Set the API key in global config
+ */
+export function setApiKey(apiKey) {
+  const config = loadGlobalConfig();
+  config.apiKey = apiKey;
+  saveGlobalConfig(config);
+}
+
+/**
+ * Show current configuration
+ */
+export async function showConfig() {
+  const globalConfig = loadGlobalConfig();
+  const projectConfig = loadProjectConfig();
+
+  console.log('Ropilot Configuration');
+  console.log('=====================');
+  console.log('');
+  console.log('Global config (~/.ropilot/config.json):');
+  console.log(`  API Key: ${globalConfig.apiKey ? globalConfig.apiKey.slice(0, 20) + '...' : '(not set)'}`);
+  console.log(`  Prompts Version: ${globalConfig.promptsVersion || '(not downloaded)'}`);
+  console.log(`  Last Updated: ${globalConfig.lastUpdated || 'never'}`);
+  console.log('');
+
+  if (projectConfig) {
+    console.log('Project config (.ropilot.json):');
+    console.log(`  API Key: ${projectConfig.apiKey ? projectConfig.apiKey.slice(0, 20) + '...' : '(not set)'}`);
+    console.log('');
+  }
+
+  console.log(`Edge Server: ${EDGE_URL}`);
+}

package/lib/index.js

@@ -0,0 +1,7 @@
+/**
+ * Ropilot CLI - Main exports
+ */
+
+export { init, update } from './setup.js';
+export { serve } from './proxy.js';
+export { loadGlobalConfig, saveGlobalConfig, getApiKey, setApiKey, EDGE_URL } from './config.js';

package/lib/proxy.js

@@ -0,0 +1,209 @@
+/**
+ * stdio to HTTP proxy for Ropilot MCP
+ *
+ * This module implements a stdio MCP server that proxies
+ * all requests to the Ropilot edge server.
+ */
+
+import { createInterface } from 'readline';
+import { getApiKey, EDGE_URL } from './config.js';
+
+/**
+ * Send JSON-RPC response to stdout
+ */
+function sendResponse(response) {
+  const json = JSON.stringify(response);
+  process.stdout.write(`Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`);
+}
+
+/**
+ * Send JSON-RPC error response
+ */
+function sendError(id, code, message) {
+  sendResponse({
+    jsonrpc: '2.0',
+    id,
+    error: { code, message }
+  });
+}
+
+/**
+ * Forward request to edge server
+ */
+async function forwardToEdge(apiKey, request) {
+  const url = `${EDGE_URL}/mcp/${apiKey}/message`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(request)
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Edge server error: ${response.status} ${text}`);
+    }
+
+    return await response.json();
+  } catch (err) {
+    throw new Error(`Failed to connect to edge server: ${err.message}`);
+  }
+}
+
+/**
+ * Handle MCP initialize request
+ */
+function handleInitialize(request) {
+  return {
+    jsonrpc: '2.0',
+    id: request.id,
+    result: {
+      protocolVersion: '2024-11-05',
+      capabilities: {
+        tools: {}
+      },
+      serverInfo: {
+        name: 'ropilot',
+        version: '0.1.0'
+      }
+    }
+  };
+}
+
+/**
+ * Handle MCP tools/list request
+ */
+async function handleToolsList(apiKey, request) {
+  // Forward to edge to get actual tool list
+  return await forwardToEdge(apiKey, request);
+}
+
+/**
+ * Handle MCP tools/call request
+ */
+async function handleToolsCall(apiKey, request) {
+  // Forward to edge
+  return await forwardToEdge(apiKey, request);
+}
+
+/**
+ * Process a single MCP request
+ */
+async function processRequest(apiKey, request) {
+  const method = request.method;
+
+  switch (method) {
+    case 'initialize':
+      return handleInitialize(request);
+
+    case 'initialized':
+      // Notification, no response needed
+      return null;
+
+    case 'tools/list':
+      return await handleToolsList(apiKey, request);
+
+    case 'tools/call':
+      return await handleToolsCall(apiKey, request);
+
+    default:
+      // Forward unknown methods to edge
+      return await forwardToEdge(apiKey, request);
+  }
+}
+
+/**
+ * Run the stdio MCP server
+ */
+export async function serve() {
+  const apiKey = getApiKey();
+
+  if (!apiKey) {
+    console.error('No API key configured.');
+    console.error('Run "npx ropilot init" to set up Ropilot.');
+    process.exit(1);
+  }
+
+  // Read JSON-RPC messages from stdin
+  let buffer = '';
+  let contentLength = -1;
+
+  const rl = createInterface({
+    input: process.stdin,
+    terminal: false
+  });
+
+  // Handle line-based input (for simpler clients)
+  process.stdin.on('data', (chunk) => {
+    buffer += chunk.toString();
+
+    // Try to parse Content-Length header
+    while (true) {
+      if (contentLength === -1) {
+        const headerEnd = buffer.indexOf('\r\n\r\n');
+        if (headerEnd === -1) break;
+
+        const header = buffer.slice(0, headerEnd);
+        const match = header.match(/Content-Length: (\d+)/i);
+        if (match) {
+          contentLength = parseInt(match[1], 10);
+          buffer = buffer.slice(headerEnd + 4);
+        } else {
+          // No Content-Length, try to parse as raw JSON
+          try {
+            const lineEnd = buffer.indexOf('\n');
+            if (lineEnd === -1) break;
+
+            const line = buffer.slice(0, lineEnd).trim();
+            buffer = buffer.slice(lineEnd + 1);
+
+            if (line) {
+              const request = JSON.parse(line);
+              handleRequest(apiKey, request);
+            }
+          } catch (e) {
+            buffer = buffer.slice(buffer.indexOf('\n') + 1);
+          }
+          continue;
+        }
+      }
+
+      // We have Content-Length, wait for body
+      if (buffer.length >= contentLength) {
+        const body = buffer.slice(0, contentLength);
+        buffer = buffer.slice(contentLength);
+        contentLength = -1;
+
+        try {
+          const request = JSON.parse(body);
+          handleRequest(apiKey, request);
+        } catch (e) {
+          sendError(null, -32700, 'Parse error');
+        }
+      } else {
+        break;
+      }
+    }
+  });
+
+  // Handle graceful shutdown
+  process.on('SIGINT', () => process.exit(0));
+  process.on('SIGTERM', () => process.exit(0));
+}
+
+/**
+ * Handle a parsed request
+ */
+async function handleRequest(apiKey, request) {
+  try {
+    const response = await processRequest(apiKey, request);
+    if (response) {
+      sendResponse(response);
+    }
+  } catch (err) {
+    sendError(request.id, -32000, err.message);
+  }
+}

package/lib/setup.js

@@ -0,0 +1,258 @@
+/**
+ * Setup and initialization for Ropilot CLI
+ *
+ * Handles:
+ * - First-time setup
+ * - Downloading system prompts
+ * - Creating project configs
+ */
+
+import { existsSync, writeFileSync, mkdirSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { createInterface } from 'readline';
+import {
+  loadGlobalConfig,
+  saveGlobalConfig,
+  setApiKey,
+  getApiKey,
+  EDGE_URL
+} from './config.js';
+
+// Prompts storage directory
+const PROMPTS_DIR = join(homedir(), '.ropilot', 'prompts');
+
+/**
+ * Prompt for user input
+ */
+function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise(resolve => {
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Download prompts from edge server
+ */
+async function downloadPrompts(apiKey) {
+  console.log('Downloading latest agent package...');
+
+  try {
+    // Fetch from edge server
+    const response = await fetch(`${EDGE_URL}/package`);
+    if (!response.ok) {
+      throw new Error(`Server returned ${response.status}`);
+    }
+
+    const pkg = await response.json();
+    console.log(`Package version: ${pkg.version}`);
+
+    // Ensure prompts directory exists
+    mkdirSync(PROMPTS_DIR, { recursive: true });
+
+    // Write package info
+    writeFileSync(join(PROMPTS_DIR, 'package.json'), JSON.stringify(pkg, null, 2));
+
+    // Update config with version info
+    const config = loadGlobalConfig();
+    config.promptsVersion = pkg.version;
+    config.lastUpdated = new Date().toISOString();
+    saveGlobalConfig(config);
+
+    console.log('Agent package downloaded successfully!');
+    return pkg;
+  } catch (err) {
+    console.error('Failed to download from server:', err.message);
+    console.log('Using bundled defaults...');
+
+    // Fallback to bundled defaults
+    const prompts = getDefaultPrompts();
+    mkdirSync(PROMPTS_DIR, { recursive: true });
+    for (const [name, content] of Object.entries(prompts)) {
+      writeFileSync(join(PROMPTS_DIR, name), content);
+    }
+
+    const config = loadGlobalConfig();
+    config.promptsVersion = '1.0.0-bundled';
+    config.lastUpdated = new Date().toISOString();
+    saveGlobalConfig(config);
+
+    return { version: '1.0.0-bundled', files: prompts };
+  }
+}
+
+/**
+ * Get default prompts (bundled)
+ */
+function getDefaultPrompts() {
+  return {
+    'CLAUDE.md': `# Ropilot - AI-Powered Roblox Development
+
+You are connected to Ropilot, an AI assistant for Roblox Studio development.
+
+## Available Tools
+
+Ropilot provides MCP tools for interacting with Roblox Studio:
+
+### Reading & Inspection
+- \`ropilot_listchildren\` - List children of an instance
+- \`ropilot_getproperties\` - Get properties of an instance
+- \`ropilot_search\` - Search for instances by name
+- \`ropilot_searchbyclass\` - Search for instances by class name
+
+### Playtesting
+- \`ropilot_test_start_playtest\` - Start a playtest session
+- \`ropilot_test_stop_playtest\` - Stop the current playtest
+- \`ropilot_test_run_client_lua\` - Run Lua code on the client
+- \`ropilot_test_run_server_lua\` - Run Lua code on the server
+
+### Data Management
+- \`ropilot_reset_data\` - Reset player data in DataStore
+
+## Context Targeting
+
+Commands can target different contexts:
+- \`edit\` - Edit mode (default)
+- \`server\` - Server context during playtest
+- \`client\` - Client context during playtest
+
+Use the \`target_context\` parameter to specify which context should execute the command.
+
+## Best Practices
+
+1. **Read before modify** - Always inspect the current state before making changes
+2. **Use specific paths** - Reference instances by their full path (e.g., "Workspace.Map.Building")
+3. **Delegate playtesting** - Use the roblox-tester subagent for playtest operations
+4. **Test incrementally** - Start playtests to verify changes work correctly
+`,
+
+    'subagents.json': JSON.stringify({
+      "roblox-tester": {
+        "description": "Fast subagent for executing Roblox playtest steps",
+        "tools": ["ropilot_test_*", "ropilot_get_*", "ropilot_execute_lua"],
+        "prompt": "You are a Roblox playtest executor. Run the specified test steps and report results concisely."
+      }
+    }, null, 2)
+  };
+}
+
+/**
+ * Set up agent files in current project
+ */
+function setupProjectPrompts(pkg) {
+  const files = pkg.files || {};
+
+  for (const [filePath, content] of Object.entries(files)) {
+    const fullPath = filePath;
+    const dir = dirname(fullPath);
+
+    // Create directory if needed
+    if (dir && dir !== '.') {
+      mkdirSync(dir, { recursive: true });
+    }
+
+    // Check if file exists
+    if (existsSync(fullPath)) {
+      console.log(`  Exists: ${fullPath}`);
+
+      // For CLAUDE.local.md, append if Ropilot section not present
+      if (fullPath.includes('CLAUDE') && fullPath.endsWith('.md')) {
+        const existing = readFileSync(fullPath, 'utf-8');
+        if (!existing.includes('Ropilot') && !existing.includes('roblox-tester')) {
+          writeFileSync(fullPath, existing + '\n\n' + content);
+          console.log(`  Updated: ${fullPath} (added Ropilot section)`);
+        }
+      }
+    } else {
+      writeFileSync(fullPath, content);
+      console.log(`  Created: ${fullPath}`);
+    }
+  }
+}
+
+/**
+ * Initialize Ropilot in current project
+ */
+export async function init(providedApiKey = null) {
+  console.log('');
+  console.log('Welcome to Ropilot!');
+  console.log('===================');
+  console.log('');
+
+  // Get API key
+  let apiKey = providedApiKey || getApiKey();
+
+  if (!apiKey) {
+    console.log('To use Ropilot, you need an API key.');
+    console.log('Get one at: https://ropilot.ai');
+    console.log('');
+    apiKey = await prompt('Enter your API key (ropilot_...): ');
+
+    if (!apiKey || !apiKey.startsWith('ropilot_')) {
+      console.error('Invalid API key. Must start with "ropilot_"');
+      process.exit(1);
+    }
+
+    setApiKey(apiKey);
+    console.log('API key saved!');
+    console.log('');
+  } else {
+    console.log(`Using API key: ${apiKey.slice(0, 20)}...`);
+    console.log('');
+  }
+
+  // Download prompts
+  const pkg = await downloadPrompts(apiKey);
+  console.log('');
+
+  // Set up project prompts
+  console.log('Setting up project files...');
+  setupProjectPrompts(pkg);
+  console.log('');
+
+  // Done!
+  console.log('Setup complete!');
+  console.log('');
+  console.log('Next steps:');
+  console.log('1. Make sure Roblox Studio is running with the Ropilot plugin');
+  console.log('2. Add Ropilot to your AI IDE:');
+  console.log('');
+  console.log('   For Claude Desktop, add to claude_desktop_config.json:');
+  console.log('   {');
+  console.log('     "mcpServers": {');
+  console.log('       "ropilot": {');
+  console.log('         "command": "npx",');
+  console.log('         "args": ["ropilot"]');
+  console.log('       }');
+  console.log('     }');
+  console.log('   }');
+  console.log('');
+  console.log('   Or use HTTP directly:');
+  console.log(`   ${EDGE_URL}/mcp/${apiKey}/message`);
+  console.log('');
+}
+
+/**
+ * Update prompts to latest version
+ */
+export async function update() {
+  console.log('Checking for updates...');
+
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error('No API key configured. Run "ropilot init" first.');
+    process.exit(1);
+  }
+
+  await downloadPrompts(apiKey);
+  console.log('');
+  console.log('Update complete!');
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "ropilot",
+  "version": "0.1.2",
+  "description": "AI-powered Roblox development assistant - MCP CLI",
+  "author": "whut",
+  "license": "MIT",
+  "bin": {
+    "ropilot": "./bin/ropilot.js"
+  },
+  "main": "./lib/index.js",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "roblox",
+    "ai",
+    "mcp",
+    "claude",
+    "model-context-protocol"
+  ],
+  "homepage": "https://ropilot.ai",
+  "files": [
+    "bin/",
+    "lib/",
+    "prompts/"
+  ],
+  "dependencies": {}
+}