roport 1.0.0 → 1.2.0

package/README.md

@@ -1,6 +1,6 @@
 # Roport CLI
 
-The companion server for the **Roport** Roblox plugin. This tool enables two-way syncing between Visual Studio Code and Roblox Studio.
+The companion server for the **Roport** Roblox plugin. This tool enables two-way syncing between Visual Studio Code and Roblox Studio and provides a "Gold Standard" development environment.
 
 ## Installation
 
@@ -12,7 +12,21 @@ npm install -g roport
 
 ## Usage
 
-Navigate to your project directory (where your `.meta.json` files are) and run:
+### Initialize a New Project
+To create a new project with the standard folder structure and pre-installed modules (ByteNet, Fusion, Matter, etc.):
+
+```bash
+roport init
+```
+
+This will create:
+- `src/`: Source code directory with `server`, `client`, and `shared` folders.
+- `default.project.json`: Rojo configuration.
+- `MODULE_ARCHITECTURE.md`: Documentation for the installed modules.
+- `AI_INSTRUCTIONS.md`: Guide for AI assistants and developers.
+
+### Start the Sync Server
+Navigate to your project directory and run:
 
 ```bash
 roport serve
@@ -27,6 +41,23 @@ This will start a local server on port `3456` (default).
 ## Setup with Roblox
 
 1. Install this CLI tool.
-2. Install the **Roport** plugin in Roblox Studio.
+2. Run `roport init` in your project folder.
 3. Start the server with `roport serve`.
-4. Connect via the plugin in Roblox Studio.
+4. Install the **Roport** plugin in Roblox Studio.
+5. Connect via the plugin in Roblox Studio.
+
+## Diagnostics
+
+When the Roport plugin loads in Roblox Studio, it will automatically run a diagnostic check and output the results to the Output window. This check verifies:
+- Connection to the Roport server.
+- Correct mapping of project folders (`Shared`, `Server`, `Client`).
+
+Look for the `[Roport]` prefix in the console to see the status.
+
+## Testing
+
+To run the integration test suite for the CLI:
+
+```bash
+node test/test_suite.js
+```

package/bin/roport.js

@@ -2,6 +2,9 @@
 
 const { program } = require('commander');
 const { startServer } = require('../src/server');
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
 
 program
   .name('roport')
@@ -16,4 +19,28 @@ program
     startServer(parseInt(options.port));
   });
 
+program
+  .command('init')
+  .description('Initialize a new Roport project with standard modules')
+  .action(async () => {
+    const targetDir = process.cwd();
+    const templateDir = path.join(__dirname, '../templates/default');
+
+    console.log(chalk.blue(`Initializing Roport project in ${targetDir}...`));
+
+    try {
+      if (await fs.pathExists(templateDir)) {
+        await fs.copy(templateDir, targetDir);
+        console.log(chalk.green('Success! Project initialized.'));
+        console.log(chalk.white('Run `roport serve` to start the sync server.'));
+        console.log(chalk.white('Check DOCUMENTATION.md for usage details.'));
+        console.log(chalk.white('Install RoportSyncPlugin.rbxmx in your Roblox Studio project.'));
+      } else {
+        console.error(chalk.red(`Error: Template directory not found at ${templateDir}`));
+      }
+    } catch (err) {
+      console.error(chalk.red('Error initializing project:'), err);
+    }
+  });
+
 program.parse();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "roport",
-  "version": "1.0.0",
-  "description": "A sync server for Roblox development. Works with the Roport Roblox Plugin.",
+  "version": "1.2.0",
+  "description": "A sync server for Roblox development. Works with the Roport Roblox Plugin. Features AI integration and full project sync.",
   "main": "src/server.js",
   "bin": {
     "roport": "./bin/roport.js"
@@ -25,6 +25,7 @@
   "files": [
     "bin",
     "src",
+    "templates",
     "README.md"
   ],
   "dependencies": {

package/src/server.js

@@ -18,21 +18,20 @@ function startServer(port) {
 
     // State for two-way sync
     let changedFiles = new Set();
+    let commandQueue = []; // Queue for commands to be sent to Roblox
+    let executionResults = new Map(); // Store results of executed scripts
     let isWriting = false; // Lock to prevent loops (Roblox -> File -> Watcher -> Roblox)
 
     // Watch for file changes locally
     try {
         console.log(chalk.gray(`Starting file watcher on ${projectRoot}...`));
         fs.watch(projectRoot, { recursive: true }, (eventType, filename) => {
-            // Debug log
-            // console.log('Raw event:', eventType, filename);
-
             if (filename && !isWriting) {
-                // Ignore system folders and the cli folder itself if we are watching root
-                if (filename.includes('node_modules') || filename.includes('.git') || filename.startsWith('cli')) return;
-                
                 // Normalize path to forward slashes
                 const relativePath = filename.replace(/\\/g, '/');
+
+                // Check ignore rules
+                if (isIgnored(relativePath)) return;
                 
                 // Debounce/Deduplicate slightly
                 if (!changedFiles.has(relativePath)) {
@@ -48,40 +47,228 @@ function startServer(port) {
     // Increase limit for large file batches
     app.use(express.json({ limit: '50mb' }));
 
+    // Ignore Logic
+    let ignoreRules = [];
+
+    function loadIgnoreRules() {
+        ignoreRules = [];
+        const ignoreFiles = ['.rojoignore', '.gitignore'];
+        
+        for (const file of ignoreFiles) {
+            const ignorePath = path.join(projectRoot, file);
+            if (fs.existsSync(ignorePath)) {
+                try {
+                    const content = fs.readFileSync(ignorePath, 'utf8');
+                    const lines = content.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+                    ignoreRules.push(...lines);
+                    console.log(chalk.gray(`Loaded ${lines.length} ignore rules from ${file}`));
+                } catch (e) {
+                    console.warn(chalk.yellow(`Failed to read ${file}:`), e);
+                }
+            }
+        }
+        // Always ignore internal folders
+        ignoreRules.push('.git', 'node_modules', 'cli');
+    }
+    loadIgnoreRules();
+
+    function isIgnored(filePath) {
+        // Normalize path
+        const relativePath = filePath.replace(/\\/g, '/');
+        
+        for (const rule of ignoreRules) {
+            // Simple glob matching
+            // 1. Exact match
+            if (relativePath === rule) return true;
+            
+            // 2. Directory match (rule ends with /)
+            if (rule.endsWith('/') && relativePath.startsWith(rule)) return true;
+            
+            // 3. Extension match (*.lua)
+            if (rule.startsWith('*.') && relativePath.endsWith(rule.slice(1))) return true;
+            
+            // 4. Folder match (node_modules) - check if it's a segment
+            if (!rule.includes('/') && !rule.includes('*')) {
+                const segments = relativePath.split('/');
+                if (segments.includes(rule)) return true;
+            }
+
+            // 5. Basic wildcard (src/*)
+            if (rule.endsWith('/*')) {
+                const base = rule.slice(0, -2);
+                if (relativePath.startsWith(base + '/') && relativePath.split('/').length === base.split('/').length + 1) return true;
+            }
+            
+            // 6. Recursive wildcard (src/**)
+            if (rule.endsWith('/**')) {
+                const base = rule.slice(0, -3);
+                if (relativePath.startsWith(base + '/')) return true;
+            }
+        }
+        return false;
+    }
+
+    // Project Configuration Parsing
+    function getProjectConfig() {
+        const configPath = path.join(projectRoot, 'default.project.json');
+        if (fs.existsSync(configPath)) {
+            try {
+                const config = fs.readJsonSync(configPath);
+                const mounts = [];
+                
+                function traverse(node, currentPath) {
+                    if (node.$path) {
+                        mounts.push({
+                            robloxPath: currentPath,
+                            filePath: node.$path,
+                            className: node.$className
+                        });
+                    }
+                    
+                    for (const key in node) {
+                        if (!key.startsWith('$') && typeof node[key] === 'object') {
+                            traverse(node[key], [...currentPath, key]);
+                        }
+                    }
+                }
+                
+                if (config.tree) {
+                    traverse(config.tree, []);
+                }
+                
+                return { name: config.name, mounts };
+            } catch (e) {
+                console.error(chalk.red("Failed to parse default.project.json:"), e);
+            }
+        }
+        return null;
+    }
+
+    app.get('/config', (req, res) => {
+        const config = getProjectConfig();
+        if (config) {
+            res.send(config);
+        } else {
+            // Fallback for legacy projects without config
+            res.send({
+                mounts: [
+                    { robloxPath: ["ServerScriptService"], filePath: "src/server" },
+                    { robloxPath: ["ReplicatedStorage"], filePath: "src/shared" },
+                    { robloxPath: ["StarterPlayer", "StarterPlayerScripts"], filePath: "src/client" },
+                    { robloxPath: ["Workspace"], filePath: "src/workspace" },
+                    { robloxPath: ["StarterGui"], filePath: "src/interface" },
+                    { robloxPath: ["StarterPack"], filePath: "src/tools" },
+                    { robloxPath: ["Lighting"], filePath: "src/lighting" },
+                    { robloxPath: ["ReplicatedFirst"], filePath: "src/first" },
+                    { robloxPath: ["SoundService"], filePath: "src/sounds" }
+                ]
+            });
+        }
+    });
+
     app.get('/ping', (req, res) => {
         res.send('pong');
     });
 
     // New endpoint for Roblox to poll for changes
     app.get('/poll', async (req, res) => {
-        if (changedFiles.size === 0) {
-            return res.send({ changes: [] });
+        const response = { changes: [], deletions: [], commands: [] };
+
+        // Handle Commands
+        if (commandQueue.length > 0) {
+            response.commands = [...commandQueue];
+            commandQueue = []; // Clear queue
+            console.log(chalk.magenta(`Sending ${response.commands.length} commands to Roblox`));
         }
 
-        const changes = [];
-        const filesToProcess = Array.from(changedFiles);
-        changedFiles.clear(); // Clear immediately so we don't send duplicates
+        // Handle File Changes & Deletions
+        if (changedFiles.size > 0) {
+            const filesToProcess = Array.from(changedFiles);
+            changedFiles.clear(); // Clear immediately so we don't send duplicates
 
-        for (const filePath of filesToProcess) {
-            try {
-                const fullPath = path.resolve(projectRoot, filePath);
-                // Only send if file still exists (it might have been deleted)
-                if (await fs.pathExists(fullPath)) {
-                    const stat = await fs.stat(fullPath);
-                    if (stat.isFile()) {
-                        const content = await fs.readFile(fullPath, 'utf8');
-                        changes.push({ filePath, content });
+            for (const filePath of filesToProcess) {
+                try {
+                    const fullPath = path.resolve(projectRoot, filePath);
+                    
+                    if (await fs.pathExists(fullPath)) {
+                        // File Exists -> Update
+                        const stat = await fs.stat(fullPath);
+                        if (stat.isFile()) {
+                            const content = await fs.readFile(fullPath, 'utf8');
+                            response.changes.push({ filePath, content });
+                        } else if (stat.isDirectory()) {
+                            response.changes.push({ filePath, isDirectory: true });
+                        }
+                    } else {
+                        // File Does Not Exist -> Deletion
+                        response.deletions.push(filePath);
                     }
+                } catch (e) {
+                    console.error(chalk.red(`Error reading changed file ${filePath}:`), e);
                 }
-            } catch (e) {
-                console.error(chalk.red(`Error reading changed file ${filePath}:`), e);
+            }
+            
+            if (response.changes.length > 0) {
+                console.log(chalk.magenta(`Sending ${response.changes.length} updates to Roblox`));
+            }
+            if (response.deletions.length > 0) {
+                console.log(chalk.magenta(`Sending ${response.deletions.length} deletions to Roblox`));
             }
         }
 
-        if (changes.length > 0) {
-            console.log(chalk.magenta(`Sending ${changes.length} updates to Roblox`));
+        res.send(response);
+    });
+
+    app.post('/log', (req, res) => {
+        const { message, type, timestamp } = req.body;
+        const timeStr = new Date((timestamp || Date.now() / 1000) * 1000).toLocaleTimeString();
+        
+        let color = chalk.white;
+        if (type === 2 || type === 'Error') color = chalk.red; // Error
+        else if (type === 1 || type === 'Warning') color = chalk.yellow; // Warning
+        
+        console.log(chalk.gray(`[STUDIO ${timeStr}]`) + " " + color(message));
+        res.send({ success: true });
+    });
+
+    // AI Interface: Remote Execution
+    app.post('/execute', (req, res) => {
+        const { code } = req.body;
+        if (!code) return res.status(400).send('Missing code');
+        
+        const id = Date.now().toString();
+        commandQueue.push({ type: 'EXECUTE', id, code });
+        console.log(chalk.blue(`Queued execution ${id}`));
+        
+        // Wait for result (long polling implementation could be better, but simple polling works for now)
+        res.send({ id, status: 'queued' });
+    });
+
+    app.post('/execute-result', (req, res) => {
+        const { id, success, result, error } = req.body;
+        executionResults.set(id, { success, result, error });
+        console.log(chalk.blue(`Received result for ${id}: ${success ? 'Success' : 'Failed'}`));
+        res.send({ success: true });
+    });
+
+    app.get('/execute/:id', (req, res) => {
+        const { id } = req.params;
+        if (executionResults.has(id)) {
+            const result = executionResults.get(id);
+            executionResults.delete(id); // Consume result
+            res.send({ status: 'completed', ...result });
+        } else {
+            res.send({ status: 'pending' });
         }
-        res.send({ changes });
+    });
+
+    app.post('/command', (req, res) => {
+        const { type, path } = req.body;
+        if (!type) return res.status(400).send('Missing command type');
+        
+        commandQueue.push({ type, path });
+        console.log(chalk.blue(`Queued command: ${type}`));
+        res.send({ success: true });
     });
 
     app.post('/batch', async (req, res) => {
@@ -105,6 +292,11 @@ function startServer(port) {
                     continue;
                 }
 
+                if (isIgnored(filePath)) {
+                    console.log(chalk.gray(`Skipping ignored file: ${filePath}`));
+                    continue;
+                }
+
                 if (filePath.endsWith('.json')) {
                     try {
                         const json = JSON.parse(content);
@@ -145,6 +337,11 @@ function startServer(port) {
                     continue;
                 }
 
+                if (isIgnored(filePath)) {
+                    console.log(chalk.gray(`Skipping ignored file deletion: ${filePath}`));
+                    continue;
+                }
+
                 if (await fs.pathExists(safePath)) {
                     await fs.remove(safePath);
                     console.log(chalk.magenta(`Deleted: ${filePath}`));