roport 1.4.0 → 2.0.1

package/src/ignore.js

@@ -1,120 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-
-class IgnoreManager {
-    constructor(projectRoot) {
-        this.projectRoot = projectRoot;
-        this.rules = [];
-        this.cache = new Map(); // Cache for scalability
-        this.loadRules();
-    }
-
-    loadRules() {
-        this.rules = [];
-        this.cache.clear();
-        // Default ignores
-        this.addRule('.git');
-        this.addRule('node_modules');
-        this.addRule('cli');
-        this.addRule('Roport.rbxmx');
-        this.addRule('RoportSyncPlugin.rbxmx');
-        this.addRule('.DS_Store');
-        this.addRule('package.json');
-        this.addRule('package-lock.json');
-
-        // Load from files
-        const ignoreFiles = ['.rojoignore', '.gitignore'];
-        for (const file of ignoreFiles) {
-            const ignorePath = path.join(this.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('#'));
-                    lines.forEach(line => this.addRule(line));
-                } catch (e) {
-                    // Ignore read errors
-                }
-            }
-        }
-    }
-
-    addRule(rule) {
-        this.rules.push(rule);
-    }
-
-    isIgnored(filePath) {
-        if (this.cache.has(filePath)) {
-            return this.cache.get(filePath);
-        }
-
-        // If filePath is absolute, make it relative
-        let relativePath = filePath;
-        if (path.isAbsolute(filePath)) {
-            relativePath = path.relative(this.projectRoot, filePath);
-        }
-        
-        // Normalize to forward slashes
-        relativePath = relativePath.replace(/\\/g, '/');
-        
-        if (relativePath.startsWith('../')) {
-            this.cache.set(filePath, true);
-            return true; // Outside project
-        }
-        if (relativePath === '' || relativePath === '.') {
-            this.cache.set(filePath, false);
-            return false; // Root
-        }
-
-        for (const rule of this.rules) {
-            // 1. Exact match
-            if (relativePath === rule) {
-                this.cache.set(filePath, true);
-                return true;
-            }
-            
-            // 2. Directory match (rule ends with /)
-            if (rule.endsWith('/') && relativePath.startsWith(rule)) {
-                this.cache.set(filePath, true);
-                return true;
-            }
-            
-            // 3. Extension match (*.lua)
-            if (rule.startsWith('*.') && relativePath.endsWith(rule.slice(1))) {
-                this.cache.set(filePath, true);
-                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)) {
-                    this.cache.set(filePath, true);
-                    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) {
-                    this.cache.set(filePath, true);
-                    return true;
-                }
-            }
-            
-            // 6. Recursive wildcard (src/**)
-            if (rule.endsWith('/**')) {
-                const base = rule.slice(0, -3);
-                if (relativePath.startsWith(base + '/')) {
-                    this.cache.set(filePath, true);
-                    return true;
-                }
-            }
-        }
-        
-        this.cache.set(filePath, false);
-        return false;
-    }
-}
-
-module.exports = IgnoreManager;

package/src/server.js

@@ -1,393 +0,0 @@
-const express = require('express');
-const fs = require('fs-extra');
-const path = require('path');
-const chalk = require('chalk');
-
-function createApp(projectRoot) {
-    const app = express();
-    
-    // Determine project root
-    if (!projectRoot) {
-        projectRoot = process.cwd();
-        if (fs.existsSync(path.join(projectRoot, 'src'))) {
-            // We are in the root
-        } else if (fs.existsSync(path.join(projectRoot, '../src'))) {
-            // We are in cli/ or similar
-            projectRoot = path.resolve(projectRoot, '..');
-        }
-    }
-    console.log(chalk.cyan(`Project Root: ${projectRoot}`));
-
-    // 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
-    let watcher;
-    try {
-        console.log(chalk.gray(`Starting file watcher on ${projectRoot}...`));
-        watcher = fs.watch(projectRoot, { recursive: true }, (eventType, filename) => {
-            if (filename && !isWriting) {
-                // Normalize path to forward slashes
-                const relativePath = filename.replace(/\\/g, '/');
-
-                // Check ignore rules
-                if (isIgnored(relativePath)) return;
-                
-                // Debounce/Deduplicate slightly
-                if (!changedFiles.has(relativePath)) {
-                    changedFiles.add(relativePath);
-                    console.log(chalk.yellow(`File changed: ${relativePath} (${eventType})`));
-                }
-            }
-        });
-    } catch (e) {
-        console.warn(chalk.red("File watching failed (might not be supported on this OS):"), e);
-    }
-
-    app.close = () => {
-        if (watcher) watcher.close();
-    };
-
-    // Increase limit for large file batches
-    app.use(express.json({ limit: '50mb' }));
-
-    // Ignore Logic
-    const IgnoreManager = require('./ignore');
-    const ignoreManager = new IgnoreManager(projectRoot);
-
-    function isIgnored(filePath) {
-        return ignoreManager.isIgnored(filePath);
-    }
-
-    // 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) {
-                    const info = {
-                        robloxPath: currentPath,
-                        properties: node.$properties,
-                        ignoreUnknownInstances: node.$ignoreUnknownInstances,
-                        className: node.$className
-                    };
-
-                    if (node.$path) {
-                        info.filePath = node.$path;
-                    }
-                    
-                    // Push if it's a mount point (has path) or has configuration
-                    if (info.filePath || info.properties || info.className || info.ignoreUnknownInstances) {
-                         mounts.push(info);
-                    }
-                    
-                    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');
-    });
-
-    // AI Helper: Get Project Tree
-    app.get('/tree', async (req, res) => {
-        try {
-            const contextGen = require('./context');
-            const tree = await contextGen.generate(projectRoot, { maxDepth: 5, includeSource: false });
-            res.send({ tree });
-        } catch (e) {
-            res.status(500).send({ error: e.message });
-        }
-    });
-
-    // New endpoint for Roblox to poll for changes
-    app.get('/poll', async (req, res) => {
-        const response = { changes: [], deletions: [], commands: [] };
-        const MAX_CHANGES_PER_POLL = 50; // Scalability: Batch size limit
-
-        // Handle Commands
-        if (commandQueue.length > 0) {
-            response.commands = [...commandQueue];
-            commandQueue = []; // Clear queue
-            console.log(chalk.magenta(`Sending ${response.commands.length} commands to Roblox`));
-        }
-
-        // Handle File Changes & Deletions
-        if (changedFiles.size > 0) {
-            // Convert to array to slice, but we need to be careful about concurrent updates
-            const allFiles = Array.from(changedFiles);
-            const batch = allFiles.slice(0, MAX_CHANGES_PER_POLL);
-            
-            // Remove these from the set immediately so we don't process them again
-            // If processing fails, we might lose them, but for now this is acceptable for scalability
-            batch.forEach(f => changedFiles.delete(f));
-
-            for (const filePath of batch) {
-                try {
-                    const fullPath = path.resolve(projectRoot, filePath);
-                    
-                    if (await fs.pathExists(fullPath)) {
-                        // File Exists -> Update
-                        const stat = await fs.stat(fullPath);
-                        if (stat.isFile()) {
-                            // Check for binary files
-                            if (filePath.endsWith('.rbxm') || filePath.endsWith('.png') || filePath.endsWith('.jpg')) {
-                                // For binary files, we don't send content (or we could send base64)
-                                // Sync.lua currently uses absolutePath for .rbxm, so content is ignored.
-                                // Sending empty content prevents utf8 corruption errors.
-                                response.changes.push({ filePath, absolutePath: fullPath, content: "" });
-                            } else {
-                                const content = await fs.readFile(fullPath, 'utf8');
-                                response.changes.push({ filePath, absolutePath: fullPath, content });
-                            }
-                        } else if (stat.isDirectory()) {
-                            response.changes.push({ filePath, absolutePath: fullPath, isDirectory: true });
-                        }
-                    } else {
-                        // File Does Not Exist -> Deletion
-                        response.deletions.push(filePath);
-                    }
-                } 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 (Batch of ${batch.length})`));
-            }
-            if (response.deletions.length > 0) {
-                console.log(chalk.magenta(`Sending ${response.deletions.length} deletions to Roblox`));
-            }
-            
-            // If there are more changes pending, we could hint the client to poll again immediately
-            if (changedFiles.size > 0) {
-                response.morePending = true;
-            }
-        }
-
-        res.send(response);
-    });
-
-    app.post('/move', async (req, res) => {
-        const { oldPath, newPath } = req.body;
-        
-        if (!oldPath || !newPath) {
-            return res.status(400).send('Missing paths');
-        }
-
-        const safeOld = path.resolve(projectRoot, oldPath);
-        const safeNew = path.resolve(projectRoot, newPath);
-
-        if (!safeOld.startsWith(projectRoot) || !safeNew.startsWith(projectRoot)) {
-            return res.status(400).send('Unsafe path');
-        }
-
-        console.log(chalk.blue(`Moving ${oldPath} -> ${newPath}`));
-        isWriting = true;
-
-        try {
-            if (await fs.pathExists(safeOld)) {
-                await fs.move(safeOld, safeNew, { overwrite: true });
-                console.log(chalk.green(`Moved successfully`));
-                res.send({ success: true });
-            } else {
-                res.status(404).send('Old path not found');
-            }
-        } catch (err) {
-            console.error(chalk.red('Move failed:'), err);
-            res.status(500).send({ error: err.message });
-        } finally {
-            setTimeout(() => { isWriting = false; }, 500);
-        }
-    });
-
-    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' });
-        }
-    });
-
-    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) => {
-        const { files } = req.body;
-        
-        if (!files || !Array.isArray(files)) {
-            return res.status(400).send('Invalid body');
-        }
-
-        console.log(chalk.blue(`Received batch of ${files.length} files`));
-        
-        isWriting = true; // Lock watcher
-
-        try {
-            for (const file of files) {
-                const { filePath, content } = file;
-                // Prevent directory traversal
-                const safePath = path.resolve(projectRoot, filePath);
-                if (!safePath.startsWith(projectRoot)) {
-                    console.warn(chalk.yellow(`Skipping unsafe path: ${filePath}`));
-                    continue;
-                }
-
-                if (isIgnored(filePath)) {
-                    console.log(chalk.gray(`Skipping ignored file: ${filePath}`));
-                    continue;
-                }
-
-                if (filePath.endsWith('.json')) {
-                    try {
-                        const json = JSON.parse(content);
-                        await fs.outputFile(safePath, JSON.stringify(json, null, 2));
-                    } catch (e) {
-                        await fs.outputFile(safePath, content);
-                    }
-                } else {
-                    await fs.outputFile(safePath, content);
-                }
-                console.log(chalk.green(`Synced: ${filePath}`));
-            }
-            res.send({ success: true });
-        } catch (err) {
-            console.error(chalk.red('Error syncing files:'), err);
-            res.status(500).send({ error: err.message });
-        } finally {
-            // Release lock after a short delay to let FS settle
-            setTimeout(() => { isWriting = false; }, 500);
-        }
-    });
-
-    app.post('/delete', async (req, res) => {
-        const { files } = req.body;
-        
-        if (!files || !Array.isArray(files)) {
-            return res.status(400).send('Invalid body');
-        }
-
-        console.log(chalk.blue(`Received delete request for ${files.length} files`));
-
-        try {
-            for (const filePath of files) {
-                // Prevent directory traversal
-                const safePath = path.resolve(projectRoot, filePath);
-                if (!safePath.startsWith(projectRoot)) {
-                    console.warn(chalk.yellow(`Skipping unsafe delete path: ${filePath}`));
-                    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}`));
-                }
-            }
-            res.send({ success: true });
-        } catch (err) {
-            console.error(chalk.red('Error deleting files:'), err);
-            res.status(500).send({ error: err.message });
-        }
-    });
-
-    return app;
-}
-
-function startServer(port) {
-    const app = createApp();
-    return app.listen(port, () => {
-        console.log(chalk.cyan(`Roport server running on http://127.0.0.1:${port}`));
-        console.log(chalk.gray('Waiting for requests...'));
-    });
-}
-
-module.exports = { startServer, createApp };

package/templates/default/README.md

@@ -1,28 +0,0 @@
-# Roport Project
-
-This project was initialized with [Roport](https://github.com/Rydaguy101/RojoExportPlugin).
-
-## Getting Started
-
-1.  **Start the Sync Server:**
-    ```bash
-    roport serve
-    ```
-
-2.  **Connect in Roblox Studio:**
-    -   Install the **Roport Sync Plugin**.
-    -   Click **Connect** in the plugin toolbar.
-
-## Project Structure
-
--   `src/server`: Server-side scripts (ServerScriptService)
--   `src/client`: Client-side scripts (StarterPlayerScripts)
--   `src/shared`: Shared modules (ReplicatedStorage)
--   `src/workspace`: Workspace objects
--   `default.project.json`: Project configuration (Rojo-compatible)
-
-## Commands
-
--   `roport serve`: Start sync server
--   `roport build -o MyGame.rbxmx`: Build project to model file
--   `roport context`: Generate AI context summary

package/templates/default/default.project.json

@@ -1,23 +0,0 @@
-{
-  "name": "RoportProject",
-  "tree": {
-    "$className": "DataModel",
-    "ServerScriptService": {
-      "$path": "src/server"
-    },
-    "ReplicatedStorage": {
-      "$path": "src/shared"
-    },
-    "StarterPlayer": {
-      "StarterPlayerScripts": {
-        "$path": "src/client"
-      }
-    },
-    "Workspace": {
-      "$path": "src/workspace"
-    },
-    "Lighting": {
-      "$path": "src/lighting"
-    }
-  }
-}

package/templates/default/src/client/init.client.lua

@@ -1 +0,0 @@
-print("Hello from Roport Client!")

package/templates/default/src/server/init.server.lua

@@ -1 +0,0 @@
-print("Hello from Roport Server!")

package/templates/default/src/shared/Hello.lua

@@ -1,7 +0,0 @@
-local module = {}
-
-function module.world()
-    print("Hello World from Shared!")
-end
-
-return module