fscr 6.2.6 → 7.3.0

package/dist/lib/diagnostics/fileSystem.js

@@ -0,0 +1,236 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+
+/**
+ * Check fscripts.md file
+ * @param {Object} options - Check options
+ * @returns {Object} Check result
+ */
+export async function checkFScriptsFile(options = {}) {
+    const result = {
+        name: 'fscripts.md file',
+        passed: false,
+        warning: false,
+        message: '',
+        details: {},
+        canFix: true,
+        fix: null
+    };
+
+    try {
+        const fscriptsPath = path.join(process.cwd(), 'fscripts.md');
+
+        if (await fs.pathExists(fscriptsPath)) {
+            const stats = await fs.stat(fscriptsPath);
+            result.passed = true;
+            result.message = `Found (${formatBytes(stats.size)})`;
+            result.details = {
+                path: fscriptsPath,
+                size: stats.size,
+                sizeFormatted: formatBytes(stats.size)
+            };
+        } else {
+            result.passed = false;
+            result.message = 'Not found';
+            result.canFix = true;
+            result.fix = async () => {
+                // Create a basic fscripts.md template
+                const template = `# Scripts
+
+## hello
+Say hello
+
+\`\`\`bash
+echo "Hello from FSCR!"
+\`\`\`
+`;
+                await fs.writeFile(fscriptsPath, template, 'utf8');
+                return 'Created basic fscripts.md template';
+            };
+        }
+    } catch (error) {
+        result.passed = false;
+        result.message = `Error checking file: ${error.message}`;
+    }
+
+    return result;
+}
+
+/**
+ * Check package.json file
+ * @param {Object} options - Check options
+ * @returns {Object} Check result
+ */
+export async function checkPackageJson(options = {}) {
+    const result = {
+        name: 'package.json',
+        passed: false,
+        warning: false,
+        message: '',
+        details: {},
+        canFix: false,
+        fix: null
+    };
+
+    try {
+        const packagePath = path.join(process.cwd(), 'package.json');
+
+        if (await fs.pathExists(packagePath)) {
+            const packageJson = await fs.readJson(packagePath);
+            const fscrVersion = packageJson.version || 'unknown';
+
+            result.passed = true;
+            result.message = `Valid (fsr@${fscrVersion})`;
+            result.details = {
+                path: packagePath,
+                version: fscrVersion,
+                name: packageJson.name
+            };
+        } else {
+            result.passed = false;
+            result.message = 'Not found';
+            result.canFix = false;
+            result.fixInstructions = 'package.json is required. Please initialize your project with npm init.';
+        }
+    } catch (error) {
+        result.passed = false;
+        result.message = `Invalid or corrupted: ${error.message}`;
+        result.canFix = false;
+    }
+
+    return result;
+}
+
+/**
+ * Check TypeScript installation
+ * @param {Object} options - Check options
+ * @returns {Object} Check result
+ */
+export async function checkTypeScript(options = {}) {
+    const result = {
+        name: 'TypeScript',
+        passed: false,
+        warning: true, // TypeScript is optional
+        message: '',
+        details: {},
+        canFix: true,
+        fix: null
+    };
+
+    try {
+        const packagePath = path.join(process.cwd(), 'package.json');
+        const packageJson = await fs.readJson(packagePath);
+
+        const hasTypeScript =
+            (packageJson.dependencies && packageJson.dependencies.typescript) ||
+            (packageJson.devDependencies && packageJson.devDependencies.typescript);
+
+        if (hasTypeScript) {
+            const version =
+                (packageJson.dependencies && packageJson.dependencies.typescript) ||
+                (packageJson.devDependencies && packageJson.devDependencies.typescript);
+            result.passed = true;
+            result.warning = false;
+            result.message = `Installed (${version})`;
+            result.details = {
+                version: version
+            };
+        } else {
+            result.passed = false;
+            result.warning = true; // It's just a warning, not critical
+            result.message = 'Not installed (optional)';
+            result.canFix = true;
+            result.fix = async () => {
+                const { execSync } = await import('child_process');
+                execSync('npm install --save-dev typescript', { stdio: 'inherit' });
+                return 'Installed TypeScript as dev dependency';
+            };
+        }
+    } catch (error) {
+        result.passed = false;
+        result.warning = true;
+        result.message = 'Not installed (optional)';
+    }
+
+    return result;
+}
+
+/**
+ * Check file permissions
+ * @param {Object} options - Check options
+ * @returns {Object} Check result
+ */
+export async function checkFilePermissions(options = {}) {
+    const result = {
+        name: 'File permissions',
+        passed: false,
+        warning: false,
+        message: '',
+        details: {},
+        canFix: true,
+        fix: null
+    };
+
+    try {
+        const testFile = path.join(process.cwd(), '.fsr-permission-test');
+
+        // Test write permission
+        try {
+            await fs.writeFile(testFile, 'test', 'utf8');
+        } catch (writeError) {
+            result.passed = false;
+            result.message = 'No write access';
+            result.canFix = false;
+            result.fixInstructions = 'Please check directory permissions and ensure you have write access.';
+            return result;
+        }
+
+        // Test read permission
+        try {
+            await fs.readFile(testFile, 'utf8');
+        } catch (readError) {
+            result.passed = false;
+            result.message = 'No read access';
+            result.canFix = false;
+            result.fixInstructions = 'Please check directory permissions and ensure you have read access.';
+            await fs.remove(testFile).catch(() => {});
+            return result;
+        }
+
+        // Clean up test file
+        await fs.remove(testFile);
+
+        result.passed = true;
+        result.message = 'Read/write access OK';
+        result.details = {
+            read: true,
+            write: true
+        };
+    } catch (error) {
+        result.passed = false;
+        result.message = `Permission check failed: ${error.message}`;
+    }
+
+    return result;
+}
+
+/**
+ * Format bytes to human-readable format
+ * @param {number} bytes - Number of bytes
+ * @returns {string} Formatted string
+ */
+function formatBytes(bytes) {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+}
+
+export default {
+    checkFScriptsFile,
+    checkPackageJson,
+    checkTypeScript,
+    checkFilePermissions
+};

package/dist/lib/diagnostics/gitCheck.js

@@ -0,0 +1,41 @@
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+/**
+ * Check Git installation
+ * @param {Object} options - Check options
+ * @returns {Object} Check result
+ */
+export async function checkGit(options = {}) {
+    const result = {
+        name: 'Git',
+        passed: false,
+        warning: false,
+        message: '',
+        details: {},
+        canFix: false,
+        fix: null
+    };
+
+    try {
+        const version = execSync('git --version', {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+
+        result.passed = true;
+        result.message = version;
+        result.details = {
+            version: version
+        };
+    } catch (error) {
+        result.passed = false;
+        result.message = 'Not installed';
+        result.canFix = false;
+        result.fixInstructions = 'Please install Git.\nVisit: https://git-scm.com/downloads';
+    }
+
+    return result;
+}
+
+export default checkGit;

package/dist/lib/diagnostics/nodeVersion.js

@@ -0,0 +1,68 @@
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+/**
+ * Compare two version strings
+ * @param {string} v1 - First version
+ * @param {string} v2 - Second version
+ * @returns {boolean} True if v1 >= v2
+ */
+function versionGte(v1, v2) {
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const p1 = parts1[i] || 0;
+        const p2 = parts2[i] || 0;
+
+        if (p1 > p2) return true;
+        if (p1 < p2) return false;
+    }
+
+    return true; // Equal
+}
+
+/**
+ * Check Node.js version
+ * @param {Object} options - Check options
+ * @returns {Object} Check result
+ */
+export async function checkNodeVersion(options = {}) {
+    const minVersion = options.minVersion || '18.0.0';
+    const result = {
+        name: 'Node.js version',
+        passed: false,
+        warning: false,
+        message: '',
+        details: {},
+        canFix: false,
+        fix: null
+    };
+
+    try {
+        const currentVersion = process.version.replace('v', '');
+        const recommended = minVersion;
+
+        result.details = {
+            current: currentVersion,
+            required: `>=${recommended}`
+        };
+
+        if (versionGte(currentVersion, recommended)) {
+            result.passed = true;
+            result.message = `v${currentVersion} (recommended: >=${recommended})`;
+        } else {
+            result.passed = false;
+            result.message = `v${currentVersion} is below recommended version >=${recommended}`;
+            result.canFix = false; // Cannot auto-fix Node.js version
+            result.fixInstructions = `Please upgrade Node.js to version ${recommended} or higher.\nVisit: https://nodejs.org/`;
+        }
+    } catch (error) {
+        result.passed = false;
+        result.message = `Failed to check Node.js version: ${error.message}`;
+    }
+
+    return result;
+}
+
+export default checkNodeVersion;

package/dist/lib/diagnostics/packageManager.js

@@ -0,0 +1,64 @@
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+/**
+ * Check package manager installation
+ * @param {Object} options - Check options
+ * @returns {Object} Check result
+ */
+export async function checkPackageManager(options = {}) {
+    const result = {
+        name: 'Package manager',
+        passed: false,
+        warning: false,
+        message: '',
+        details: {},
+        canFix: false,
+        fix: null
+    };
+
+    try {
+        // Detect which package manager is being used
+        let packageManager = 'npm';
+        let version = '';
+
+        // Check for yarn.lock
+        try {
+            const fs = await import('fs');
+            if (fs.existsSync('yarn.lock')) {
+                packageManager = 'yarn';
+            } else if (fs.existsSync('pnpm-lock.yaml')) {
+                packageManager = 'pnpm';
+            }
+        } catch (err) {
+            // Default to npm
+        }
+
+        // Get version
+        try {
+            version = execSync(`${packageManager} --version`, {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe']
+            }).trim();
+
+            result.passed = true;
+            result.message = `${packageManager} ${version} installed`;
+            result.details = {
+                manager: packageManager,
+                version: version
+            };
+        } catch (error) {
+            result.passed = false;
+            result.message = `${packageManager} not found`;
+            result.canFix = false;
+            result.fixInstructions = `Please install ${packageManager}.\nVisit: https://docs.npmjs.com/downloading-and-installing-node-js-and-npm`;
+        }
+    } catch (error) {
+        result.passed = false;
+        result.message = `Failed to check package manager: ${error.message}`;
+    }
+
+    return result;
+}
+
+export default checkPackageManager;

package/dist/lib/diagnostics/performance.js

@@ -0,0 +1,141 @@
+import chalk from 'chalk';
+import { performance } from 'perf_hooks';
+
+/**
+ * Check startup time
+ * @param {Object} options - Check options
+ * @returns {Object} Check result
+ */
+export async function checkStartupTime(options = {}) {
+    const result = {
+        name: 'Startup time',
+        passed: false,
+        warning: false,
+        message: '',
+        details: {},
+        canFix: false,
+        fix: null
+    };
+
+    try {
+        // Calculate startup time from process start
+        const startupTime = performance.now();
+        const targetTime = 50; // 50ms target
+
+        result.details = {
+            time: startupTime,
+            target: targetTime,
+            unit: 'ms'
+        };
+
+        if (startupTime <= targetTime) {
+            result.passed = true;
+            result.message = `${startupTime.toFixed(2)}ms (target: <${targetTime}ms)`;
+        } else if (startupTime <= targetTime * 2) {
+            result.passed = true;
+            result.warning = true;
+            result.message = `${startupTime.toFixed(2)}ms (slightly above target of ${targetTime}ms)`;
+        } else {
+            result.passed = false;
+            result.message = `${startupTime.toFixed(2)}ms (target: <${targetTime}ms)`;
+            result.fixInstructions = 'Consider clearing cache or reducing number of plugins/hooks.';
+        }
+    } catch (error) {
+        result.passed = false;
+        result.message = `Failed to check startup time: ${error.message}`;
+    }
+
+    return result;
+}
+
+/**
+ * Check memory usage
+ * @param {Object} options - Check options
+ * @returns {Object} Check result
+ */
+export async function checkMemoryUsage(options = {}) {
+    const result = {
+        name: 'Memory usage',
+        passed: false,
+        warning: false,
+        message: '',
+        details: {},
+        canFix: false,
+        fix: null
+    };
+
+    try {
+        const usage = process.memoryUsage();
+        const heapUsedMB = Math.round((usage.heapUsed / 1024 / 1024) * 100) / 100;
+        const externalMB = Math.round((usage.external / 1024 / 1024) * 100) / 100;
+        const totalMB = heapUsedMB + externalMB;
+        const targetMB = 50; // 50MB target
+
+        result.details = {
+            heapUsed: heapUsedMB,
+            external: externalMB,
+            total: totalMB,
+            unit: 'MB',
+            raw: usage
+        };
+
+        if (totalMB <= targetMB) {
+            result.passed = true;
+            result.message = `${totalMB}MB (target: <${targetMB}MB)`;
+        } else if (totalMB <= targetMB * 1.5) {
+            result.passed = true;
+            result.warning = true;
+            result.message = `${totalMB}MB (slightly above target of ${targetMB}MB)`;
+        } else {
+            result.passed = false;
+            result.message = `${totalMB}MB (target: <${targetMB}MB)`;
+            result.fixInstructions = 'Memory usage is high. Consider optimizing dependencies or clearing cache.';
+        }
+    } catch (error) {
+        result.passed = false;
+        result.message = `Failed to check memory usage: ${error.message}`;
+    }
+
+    return result;
+}
+
+/**
+ * Run performance benchmark
+ * @param {Object} options - Benchmark options
+ * @returns {Object} Benchmark result
+ */
+export async function runBenchmark(options = {}) {
+    const runs = options.runs || 5;
+    const results = [];
+
+    for (let i = 0; i < runs; i++) {
+        const start = performance.now();
+
+        // Simulate a typical FSCR operation (parsing scripts file)
+        // In real implementation, this would run actual operations
+        await new Promise((resolve) => setTimeout(resolve, 1));
+
+        const end = performance.now();
+        results.push(end - start);
+    }
+
+    const avg = results.reduce((a, b) => a + b, 0) / results.length;
+    const min = Math.min(...results);
+    const max = Math.max(...results);
+    const median = results.sort((a, b) => a - b)[Math.floor(results.length / 2)];
+
+    return {
+        average: avg,
+        median: median,
+        min: min,
+        max: max,
+        runs: runs,
+        results: results
+    };
+}
+
+export default {
+    checkStartupTime,
+    checkMemoryUsage,
+    runBenchmark
+};

package/dist/lib/encryption/decryptConfig.js

@@ -1,4 +1,5 @@
 import encrypt from "./encryption.js";
+
 (async () => {
-  await encrypt.init();
-})();
+    await encrypt.init();
+})();