roport 1.4.0 → 2.0.0

package/src/builder.js

@@ -1,563 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const chalk = require('chalk');
-const IgnoreManager = require('./ignore');
-
-class RbxmxBuilder {
-    constructor() {
-        this.referentCount = 0;
-        this.ignoreManager = null;
-    }
-
-    generateReferent() {
-        return `RBX${this.referentCount++}`;
-    }
-
-    async writeProperties(write, properties) {
-        await write('    <Properties>\n');
-        for (const [name, value] of Object.entries(properties)) {
-            if (name === 'Source') {
-                await write(`      <ProtectedString name="Source"><![CDATA[${value}]]></ProtectedString>\n`);
-                continue;
-            }
-            
-            if (name === 'Name') {
-                await write(`      <string name="Name">${this.escapeXml(value)}</string>\n`);
-                continue;
-            }
-
-            if (typeof value === 'boolean') {
-                await write(`      <bool name="${name}">${value}</bool>\n`);
-            } else if (typeof value === 'number') {
-                await write(`      <double name="${name}">${value}</double>\n`);
-            } else if (typeof value === 'string') {
-                await write(`      <string name="${name}">${this.escapeXml(value)}</string>\n`);
-            } else if (typeof value === 'object' && value !== null && value.$type) {
-                switch (value.$type) {
-                    case 'Vector3':
-                        await write(`      <Vector3 name="${name}">
-        <X>${value.value[0]}</X>
-        <Y>${value.value[1]}</Y>
-        <Z>${value.value[2]}</Z>
-      </Vector3>\n`);
-                        break;
-                    case 'Vector2':
-                        await write(`      <Vector2 name="${name}">
-        <X>${value.value[0]}</X>
-        <Y>${value.value[1]}</Y>
-      </Vector2>\n`);
-                        break;
-                    case 'Color3':
-                         await write(`      <Color3 name="${name}">
-        <R>${value.value[0]}</R>
-        <G>${value.value[1]}</G>
-        <B>${value.value[2]}</B>
-      </Color3>\n`);
-                        break;
-                    case 'UDim2':
-                        await write(`      <UDim2 name="${name}">
-        <XS>${value.value[0]}</XS>
-        <XO>${value.value[1]}</XO>
-        <YS>${value.value[2]}</YS>
-        <YO>${value.value[3]}</YO>
-      </UDim2>\n`);
-                        break;
-                    case 'Enum':
-                        await write(`      <token name="${name}">${value.value}</token>\n`);
-                        break;
-                    case 'CFrame':
-                        // value: [x, y, z, r00, r01, r02, r10, r11, r12, r20, r21, r22]
-                        const cf = value.value;
-                        await write(`      <CoordinateFrame name="${name}">
-        <X>${cf[0]}</X><Y>${cf[1]}</Y><Z>${cf[2]}</Z>
-        <R00>${cf[3]}</R00><R01>${cf[4]}</R01><R02>${cf[5]}</R02>
-        <R10>${cf[6]}</R10><R11>${cf[7]}</R11><R12>${cf[8]}</R12>
-        <R20>${cf[9]}</R20><R21>${cf[10]}</R21><R22>${cf[11]}</R22>
-      </CoordinateFrame>\n`);
-                        break;
-                    case 'BrickColor':
-                        await write(`      <int name="${name}">${value.value}</int>\n`);
-                        break;
-                    case 'Rect':
-                        // value: [minX, minY, maxX, maxY]
-                        await write(`      <Rect2D name="${name}">
-        <min><X>${value.value[0]}</X><Y>${value.value[1]}</Y></min>
-        <max><X>${value.value[2]}</X><Y>${value.value[3]}</Y></max>
-      </Rect2D>\n`);
-                        break;
-                    case 'NumberRange':
-                        // value: [min, max]
-                        await write(`      <NumberRange name="${name}">${value.value[0]} ${value.value[1]}</NumberRange>\n`);
-                        break;
-                    case 'NumberSequence':
-                        // value: string "0 0.5 0 1 1 0" or array
-                        const nsVal = Array.isArray(value.value) ? value.value.join(' ') : value.value;
-                        await write(`      <NumberSequence name="${name}">${nsVal}</NumberSequence>\n`);
-                        break;
-                    case 'ColorSequence':
-                        // value: string or array
-                        const csVal = Array.isArray(value.value) ? value.value.join(' ') : value.value;
-                        await write(`      <ColorSequence name="${name}">${csVal}</ColorSequence>\n`);
-                        break;
-                    case 'PhysicalProperties':
-                        const pp = value.value;
-                        await write(`      <PhysicalProperties name="${name}">
-        <CustomPhysics>true</CustomPhysics>
-        <Density>${pp.Density}</Density>
-        <Friction>${pp.Friction}</Friction>
-        <Elasticity>${pp.Elasticity}</Elasticity>
-        <FrictionWeight>${pp.FrictionWeight}</FrictionWeight>
-        <ElasticityWeight>${pp.ElasticityWeight}</ElasticityWeight>
-      </PhysicalProperties>\n`);
-                        break;
-                    case 'Font':
-                        const font = value.value;
-                        await write(`      <Font name="${name}">
-        <Family><url>${font.family}</url></Family>
-        <Weight>${font.weight}</Weight>
-        <Style>${font.style}</Style>
-      </Font>\n`);
-                        break;
-                    case 'Ray':
-                        const ray = value.value; // [ox, oy, oz, dx, dy, dz]
-                        await write(`      <Ray name="${name}">
-        <origin><X>${ray[0]}</X><Y>${ray[1]}</Y><Z>${ray[2]}</Z></origin>
-        <direction><X>${ray[3]}</X><Y>${ray[4]}</Y><Z>${ray[5]}</Z></direction>
-      </Ray>\n`);
-                        break;
-                    case 'Axes':
-                        await write(`      <Axes name="${name}"><axes>${value.value}</axes></Axes>\n`);
-                        break;
-                    case 'Faces':
-                        await write(`      <Faces name="${name}"><faces>${value.value}</faces></Faces>\n`);
-                        break;
-                    case 'Ref':
-                        // value: string (referent ID)
-                        const refVal = value.value || 'null';
-                        await write(`      <Ref name="${name}">${refVal}</Ref>\n`);
-                        break;
-                    case 'BinaryString':
-                        // value: base64 string
-                        await write(`      <BinaryString name="${name}"><![CDATA[${value.value}]]></BinaryString>\n`);
-                        break;
-                    case 'UDim':
-                        // value: [scale, offset]
-                        await write(`      <UDim name="${name}">
-        <S>${value.value[0]}</S>
-        <O>${value.value[1]}</O>
-      </UDim>\n`);
-                        break;
-                    case 'Vector3int16':
-                        // value: [x, y, z]
-                        await write(`      <Vector3int16 name="${name}">
-        <X>${value.value[0]}</X>
-        <Y>${value.value[1]}</Y>
-        <Z>${value.value[2]}</Z>
-      </Vector3int16>\n`);
-                        break;
-                    case 'SharedString':
-                        // value: base64 string
-                        await write(`      <SharedString name="${name}">${value.value}</SharedString>\n`);
-                        break;
-                    case 'ProtectedString':
-                        await write(`      <ProtectedString name="${name}"><![CDATA[${value.value}]]></ProtectedString>\n`);
-                        break;
-                }
-            }
-        }
-        await write('    </Properties>\n');
-    }
-
-    escapeXml(unsafe) {
-        return String(unsafe).replace(/[<>&'"]/g, function (c) {
-            switch (c) {
-                case '<': return '&lt;';
-                case '>': return '&gt;';
-                case '&': return '&amp;';
-                case '\'': return '&apos;';
-                case '"': return '&quot;';
-            }
-        });
-    }
-
-    buildProperties(props) {
-        let xml = '    <Properties>\n';
-        for (const [name, value] of Object.entries(props)) {
-            if (name === 'Name') {
-                xml += `      <string name="Name">${this.escapeXml(value)}</string>\n`;
-            } else if (typeof value === 'boolean') {
-                xml += `      <bool name="${name}">${value}</bool>\n`;
-            } else if (typeof value === 'number') {
-                xml += `      <double name="${name}">${value}</double>\n`;
-            } else if (typeof value === 'string') {
-                xml += `      <string name="${name}">${this.escapeXml(value)}</string>\n`;
-            }
-            // TODO: Add more types (Vector3, Color3, etc) as needed
-        }
-        xml += '    </Properties>\n';
-        return xml;
-    }
-
-    async processNode(node, name, currentPath, write, initOverrideFile = null) {
-        let className = node.$className || node.type || 'Folder';
-        // Allow manual referent override for linking
-        const referent = node.$referent || this.generateReferent();
-        
-        // Determine properties
-        const properties = node.$properties || {};
-        properties.Name = name;
-
-        // Handle $path
-        let childrenProcessor = async () => {}; // Deferred children processing
-        
-        if (node.$path) {
-            const filePath = path.resolve(currentPath, node.$path);
-            if (await fs.pathExists(filePath)) {
-                const stat = await fs.stat(filePath);
-                
-                if (stat.isDirectory()) {
-                    // Check for init scripts in this directory to transform the container
-                    const initServer = path.join(filePath, 'init.server.lua');
-                    const initClient = path.join(filePath, 'init.client.lua');
-                    const initModule = path.join(filePath, 'init.lua');
-                    const initMeta = path.join(filePath, 'init.meta.json');
-                    
-                    let initContent = null;
-                    
-                    if (initOverrideFile) {
-                        // Use the provided file as the source of truth for this container
-                        if (initOverrideFile.endsWith('.server.lua') || initOverrideFile.endsWith('.server.luau')) {
-                            className = 'Script';
-                            initContent = await fs.readFile(initOverrideFile, 'utf8');
-                        } else if (initOverrideFile.endsWith('.client.lua') || initOverrideFile.endsWith('.client.luau')) {
-                            className = 'LocalScript';
-                            initContent = await fs.readFile(initOverrideFile, 'utf8');
-                        } else if (initOverrideFile.endsWith('.lua') || initOverrideFile.endsWith('.luau')) {
-                            className = 'ModuleScript';
-                            initContent = await fs.readFile(initOverrideFile, 'utf8');
-                        } else if (initOverrideFile.endsWith('.model.json')) {
-                            try {
-                                const modelData = await fs.readJson(initOverrideFile);
-                                className = modelData.className || modelData.ClassName || modelData.type || className;
-                                if (modelData.properties) Object.assign(properties, modelData.properties);
-                            } catch (e) {}
-                        }
-                    } else {
-                        // Standard init file check
-                        if (await fs.pathExists(initServer)) {
-                            className = 'Script';
-                            initContent = await fs.readFile(initServer, 'utf8');
-                        } else if (await fs.pathExists(initClient)) {
-                            className = 'LocalScript';
-                            initContent = await fs.readFile(initClient, 'utf8');
-                        } else if (await fs.pathExists(initModule)) {
-                            className = 'ModuleScript';
-                            initContent = await fs.readFile(initModule, 'utf8');
-                        }
-                        
-                        if (await fs.pathExists(initMeta)) {
-                            try {
-                                const meta = await fs.readJson(initMeta);
-                                if (meta.className) className = meta.className;
-                                if (meta.properties) Object.assign(properties, meta.properties);
-                            } catch (e) {}
-                        }
-                    }
-
-                    if (initContent !== null) {
-                        properties.Source = initContent;
-                    }
-
-                    // Process directory children
-                    childrenProcessor = async () => {
-                        const files = await fs.readdir(filePath);
-                        const entries = {};
-                        
-                        // Group files by name to handle File+Folder merging
-                        for (const file of files) {
-                            if (file.startsWith('.')) continue;
-                            
-                            if (this.ignoreManager && this.ignoreManager.isIgnored(path.join(filePath, file))) continue;
-
-                            // Determine base name
-                            let baseName = file;
-                            if (file.endsWith('.server.lua')) baseName = file.slice(0, -11);
-                            else if (file.endsWith('.client.lua')) baseName = file.slice(0, -11);
-                            else if (file.endsWith('.lua')) baseName = file.slice(0, -4);
-                            else if (file.endsWith('.server.luau')) baseName = file.slice(0, -12);
-                            else if (file.endsWith('.client.luau')) baseName = file.slice(0, -12);
-                            else if (file.endsWith('.luau')) baseName = file.slice(0, -5);
-                            else if (file.endsWith('.model.json')) baseName = file.slice(0, -11);
-                            else if (file.endsWith('.json')) baseName = file.slice(0, -5);
-                            else if (file.endsWith('.txt')) baseName = file.slice(0, -4);
-                            
-                            // Skip init files as they are handled above
-                            if (baseName === 'init' || file === 'init.meta.json') continue;
-
-                            if (!entries[baseName]) entries[baseName] = {};
-                            
-                            const childPath = path.join(filePath, file);
-                            const childStat = await fs.stat(childPath);
-                            
-                            if (childStat.isDirectory()) {
-                                entries[baseName].folder = file;
-                            } else {
-                                entries[baseName].file = file;
-                            }
-                        }
-
-                        for (const [childName, entry] of Object.entries(entries)) {
-                            if (entry.folder && entry.file) {
-                                // Merge: Process folder, but use file as init override
-                                await this.processNode({ $path: entry.folder }, childName, filePath, write, path.join(filePath, entry.file));
-                            } else if (entry.folder) {
-                                // Just a folder
-                                await this.processNode({ $path: entry.folder }, childName, filePath, write);
-                            } else if (entry.file) {
-                                // Just a file - process inline
-                                const file = entry.file;
-                                const childPath = path.join(filePath, file);
-                                
-                                let childClass = 'Folder';
-                                let content = '';
-                                let childProps = {};
-                                
-                                if (file.endsWith('.server.lua') || file.endsWith('.server.luau')) childClass = 'Script';
-                                else if (file.endsWith('.client.lua') || file.endsWith('.client.luau')) childClass = 'LocalScript';
-                                else if (file.endsWith('.lua') || file.endsWith('.luau')) childClass = 'ModuleScript';
-                                else if (file.endsWith('.txt')) childClass = 'StringValue';
-                                else if (file.endsWith('.model.json')) {
-                                    try {
-                                        const modelData = await fs.readJson(childPath);
-                                        childClass = modelData.className || modelData.ClassName || modelData.type || 'Folder';
-                                        childProps = modelData.properties || {};
-                                    } catch (e) {}
-                                }
-                                else if (file.endsWith('.json')) childClass = 'ModuleScript';
-                                
-                                if (childClass !== 'Folder' || file.endsWith('.model.json')) {
-                                    if (file.endsWith('.json') && !file.endsWith('.model.json')) {
-                                        const jsonContent = await fs.readFile(childPath, 'utf8');
-                                        content = `return game:GetService("HttpService"):JSONDecode([[${jsonContent}]])`;
-                                    } else if (!file.endsWith('.model.json')) {
-                                        content = await fs.readFile(childPath, 'utf8');
-                                    }
-                                    
-                                    const childRef = childProps.$referent || this.generateReferent();
-                                    await write(`  <Item class="${childClass}" referent="${childRef}">\n`);
-                                    
-                                    // Prepare properties
-                                    childProps.Name = childName;
-                                    if (childClass.includes('Script')) {
-                                        childProps.Source = content;
-                                    } else if (childClass === 'StringValue') {
-                                        childProps.Value = content;
-                                    }
-
-                                    await this.writeProperties(write, childProps);
-                                    await write(`  </Item>\n`);
-                                }
-                            }
-                        }
-                    };
-                } else {
-                    // It's a file mapped directly (e.g. a script)
-                    const ext = path.extname(filePath);
-                    if (ext === '.lua' || ext === '.luau') {
-                         const content = await fs.readFile(filePath, 'utf8');
-                         properties.Source = content;
-                         if (className === 'Folder') {
-                             if (filePath.endsWith('.server.lua')) className = 'Script';
-                             else if (filePath.endsWith('.client.lua')) className = 'LocalScript';
-                             else className = 'ModuleScript';
-                         }
-                    } else if (filePath.endsWith('.model.json')) {
-                        try {
-                            const modelData = await fs.readJson(filePath);
-                            className = modelData.className || modelData.ClassName || modelData.type || className;
-                            if (modelData.properties) Object.assign(properties, modelData.properties);
-                        } catch (e) {}
-                    }
-                }
-            }
-        }
-
-        await write(`  <Item class="${className}" referent="${referent}">\n`);
-        
-        await this.writeProperties(write, properties);
-        
-        // Process children
-        await childrenProcessor();
-
-        // Handle nested tree nodes
-        for (const key in node) {
-            if (!key.startsWith('$') && typeof node[key] === 'object') {
-                await this.processNode(node[key], key, currentPath, write);
-            }
-        }
-
-        await write(`  </Item>\n`);
-    }
-
-    async build(projectPath, outputPath) {
-        console.log(chalk.blue(`Building project from ${projectPath}...`));
-        
-        this.ignoreManager = new IgnoreManager(projectPath);
-
-        const configPath = path.join(projectPath, 'default.project.json');
-        if (!await fs.pathExists(configPath)) {
-            throw new Error('default.project.json not found');
-        }
-
-        const config = await fs.readJson(configPath);
-        const rootName = config.name || 'Project';
-        const tree = config.tree;
-
-        const stream = fs.createWriteStream(outputPath, { encoding: 'utf8' });
-        
-        // Helper to handle backpressure
-        const write = (chunk) => {
-            return new Promise((resolve, reject) => {
-                if (!stream.write(chunk)) {
-                    stream.once('drain', resolve);
-                } else {
-                    resolve();
-                }
-                stream.once('error', reject);
-            });
-        };
-
-        try {
-            await write('<roblox version="4">\n');
-            await this.processNode(tree, rootName, projectPath, write);
-            await write('</roblox>');
-        } finally {
-            stream.end();
-        }
-
-        console.log(chalk.green(`Build complete: ${outputPath}`));
-    }
-
-    async processNodeSourcemap(node, name, currentPath) {
-        let className = node.$className || 'Folder';
-        const children = [];
-        const filePaths = [];
-
-        // Handle $path
-        if (node.$path) {
-            const filePath = path.resolve(currentPath, node.$path);
-            if (await fs.pathExists(filePath)) {
-                filePaths.push(filePath);
-                const stat = await fs.stat(filePath);
-                
-                if (stat.isDirectory()) {
-                    // Check for init scripts
-                    const initServer = path.join(filePath, 'init.server.lua');
-                    const initClient = path.join(filePath, 'init.client.lua');
-                    const initModule = path.join(filePath, 'init.lua');
-                    
-                    if (await fs.pathExists(initServer)) {
-                        className = 'Script';
-                        filePaths.push(initServer);
-                    } else if (await fs.pathExists(initClient)) {
-                        className = 'LocalScript';
-                        filePaths.push(initClient);
-                    } else if (await fs.pathExists(initModule)) {
-                        className = 'ModuleScript';
-                        filePaths.push(initModule);
-                    }
-
-                    // Process directory children
-                    const files = await fs.readdir(filePath);
-                    for (const file of files) {
-                        if (file.startsWith('.')) continue;
-                        
-                        const childPath = path.join(filePath, file);
-                        if (this.ignoreManager && this.ignoreManager.isIgnored(childPath)) continue;
-
-                        const childStat = await fs.stat(childPath);
-                        
-                        if (childStat.isDirectory()) {
-                            children.push(await this.processNodeSourcemap({ $path: file }, file, filePath));
-                        } else {
-                            const ext = path.extname(file);
-                            const basename = path.basename(file, ext);
-                            
-                            if (basename.startsWith('init') && (ext === '.lua' || ext === '.luau')) continue;
-
-                            let childClass = 'Folder';
-                            if (file.endsWith('.server.lua') || file.endsWith('.server.luau')) childClass = 'Script';
-                            else if (file.endsWith('.client.lua') || file.endsWith('.client.luau')) childClass = 'LocalScript';
-                            else if (file.endsWith('.lua') || file.endsWith('.luau')) childClass = 'ModuleScript';
-                            else if (file.endsWith('.txt')) childClass = 'StringValue';
-                            else if (file.endsWith('.json')) childClass = 'ModuleScript';
-                            
-                            if (childClass !== 'Folder') {
-                                children.push({
-                                    name: basename.replace('.server', '').replace('.client', ''),
-                                    className: childClass,
-                                    filePaths: [childPath]
-                                });
-                            }
-                        }
-                    }
-                } else {
-                    // File mapped directly
-                    const ext = path.extname(filePath);
-                    if (ext === '.lua' || ext === '.luau') {
-                         if (className === 'Folder') {
-                             if (filePath.endsWith('.server.lua')) className = 'Script';
-                             else if (filePath.endsWith('.client.lua')) className = 'LocalScript';
-                             else className = 'ModuleScript';
-                         }
-                    }
-                }
-            }
-        }
-
-        // Handle nested tree nodes
-        for (const key in node) {
-            if (!key.startsWith('$') && typeof node[key] === 'object') {
-                children.push(await this.processNodeSourcemap(node[key], key, currentPath));
-            }
-        }
-
-        const result = {
-            name: name,
-            className: className,
-            filePaths: filePaths
-        };
-        
-        if (children.length > 0) {
-            result.children = children;
-        }
-
-        return result;
-    }
-
-    async sourcemap(projectPath, outputPath) {
-        console.log(chalk.blue(`Generating sourcemap from ${projectPath}...`));
-        
-        this.ignoreManager = new IgnoreManager(projectPath);
-
-        const configPath = path.join(projectPath, 'default.project.json');
-        if (!await fs.pathExists(configPath)) {
-            throw new Error('default.project.json not found');
-        }
-
-        const config = await fs.readJson(configPath);
-        const rootName = config.name || 'Project';
-        const tree = config.tree;
-
-        const map = await this.processNodeSourcemap(tree, rootName, projectPath);
-
-        if (outputPath) {
-            await fs.outputJson(outputPath, map, { spaces: 2 });
-            console.log(chalk.green(`Sourcemap generated: ${outputPath}`));
-        } else {
-            console.log(JSON.stringify(map, null, 2));
-        }
-    }
-}
-
-module.exports = new RbxmxBuilder();

package/src/context.js

@@ -1,76 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const chalk = require('chalk');
-const IgnoreManager = require('./ignore');
-
-class ContextGenerator {
-    constructor() {
-        this.ignoreManager = null;
-    }
-
-    async generate(dir, options = {}) {
-        const { maxDepth = 5, includeSource = false } = options;
-        this.ignoreManager = new IgnoreManager(dir);
-        let output = `# Project Context: ${path.basename(dir)}\n\n`;
-        
-        output += await this.traverse(dir, 0, maxDepth, includeSource);
-        
-        return output;
-    }
-
-    async traverse(currentPath, depth, maxDepth, includeSource) {
-        if (depth > maxDepth) return '';
-        
-        let output = '';
-        const items = await fs.readdir(currentPath);
-        
-        // Sort: Directories first, then files
-        items.sort((a, b) => {
-            const aPath = path.join(currentPath, a);
-            const bPath = path.join(currentPath, b);
-            const aStat = fs.statSync(aPath);
-            const bStat = fs.statSync(bPath);
-            if (aStat.isDirectory() && !bStat.isDirectory()) return -1;
-            if (!aStat.isDirectory() && bStat.isDirectory()) return 1;
-            return a.localeCompare(b);
-        });
-
-        for (const item of items) {
-            if (this.ignoreManager.isIgnored(path.join(currentPath, item))) continue;
-            
-            const fullPath = path.join(currentPath, item);
-            const stat = await fs.stat(fullPath);
-            const indent = '  '.repeat(depth);
-            
-            if (stat.isDirectory()) {
-                output += `${indent}- 📂 **${item}/**\n`;
-                output += await this.traverse(fullPath, depth + 1, maxDepth, includeSource);
-            } else {
-                const ext = path.extname(item);
-                let icon = '📄';
-                if (ext === '.lua' || ext === '.luau') icon = '📜';
-                if (ext === '.json') icon = '⚙️';
-                if (ext === '.model.json') icon = '📦';
-                
-                output += `${indent}- ${icon} ${item}\n`;
-                
-                if (includeSource && (ext === '.lua' || ext === '.luau' || ext === '.model.json' || item === 'default.project.json')) {
-                    try {
-                        const content = await fs.readFile(fullPath, 'utf8');
-                        // Truncate if too long
-                        if (content.length > 2000) {
-                            output += `${indent}  \`\`\`${ext.slice(1)}\n${content.slice(0, 2000)}\n... (truncated)\n  \`\`\`\n`;
-                        } else {
-                            output += `${indent}  \`\`\`${ext.slice(1)}\n${content}\n  \`\`\`\n`;
-                        }
-                    } catch (e) {
-                        output += `${indent}  *(Error reading file)*\n`;
-                    }
-                }
-            }
-        }
-        return output;
-    }
-}
-
-module.exports = new ContextGenerator();