lucy-cli 1.2.4 → 2.0.0-alpha.1

package/{src/gulp/backend.ts → src copy/gulp/backend.ts }

@@ -23,12 +23,7 @@ const swcOptions = {
 };
 
 export function buildBackend(options: TaskOptions) {
-    const folders = ['typescript'];
-    if (options.modulesSync){
-        for (const module of Object.keys(options.modulesSync)) {
-            folders.push(module);
-        }
-    }
+    const folders = ['typescript', ...options.modulesSourcePaths];
 
     const { outputDir } = options;
 
@@ -70,12 +65,8 @@ export function buildBackend(options: TaskOptions) {
 
 
 export function buildBackendJSW(options: TaskOptions) {
-    const folders = ['typescript'];
-    if (options.modulesSync){
-        for (const module of Object.keys(options.modulesSync)) {
-            folders.push(module);
-        }
-    }
+    const folders = ['typescript', ...options.modulesSourcePaths];
+
     const swcOptions = {
         jsc: {
             target: 'es6',

package/{src/gulp/checks.ts → src copy/gulp/checks.ts }

@@ -186,12 +186,8 @@ const customReporter: ts.reporter.Reporter = {
 };
 
 export function checkTs(options: TaskOptions) {
-    const folders = ['typescript'];
-    if (options.modulesSync){
-        for (const module of Object.keys(options.modulesSync)) {
-            folders.push(module);
-        }
-    }
+    const folders = ['typescript', ...options.modulesSourcePaths];
+
 
     // Create tasks for each folder
     const tasks = folders.map((folder) => {

package/{src/gulp/copy.ts → src copy/gulp/copy.ts }

@@ -4,12 +4,7 @@ import { TaskOptions } from '../Gulpfile';
 import { blue, orange, red } from '../index.js';
 
 export function copyFiles(options: TaskOptions) {
-    const folders = ['typescript'];
-    if (options.modulesSync){
-        for (const module of Object.keys(options.modulesSync)) {
-            folders.push(module);
-        }
-    }
+    const folders = ['typescript', ...options.modulesSourcePaths];
 
     // Create tasks for each folder
     const tasks = folders.map((folder) => {

package/src copy/gulp/helpers.ts

@@ -0,0 +1,26 @@
+
+import * as path from 'path';
+import * as fs from 'fs';
+
+export function getModulesSync(): Record<string, string> | undefined {
+    const absolutePath = path.resolve('./lucy.json');
+    const fileContent = fs.readFileSync(absolutePath, 'utf8') as any;
+    return JSON.parse(fileContent).modules;
+}
+
+export function getModulesSourcePaths(): string[] {
+    const absolutePath = path.resolve('./lucy.json');
+    const fileContent = fs.readFileSync(absolutePath, 'utf8') as any;
+    const data =  JSON.parse(fileContent).modules;
+    const paths: string[] = [];
+    for (const module of Object.keys(data)) {
+        if (!data[module].noCompile) {
+            if (data[module].path) {
+                paths.push(data[module].path);
+            } else {
+                paths.push(module);
+            }
+        }
+    }
+    return paths;
+}

package/{src/gulp/public.ts → src copy/gulp/public.ts }

@@ -19,12 +19,7 @@ const swcOptions = {
 };
 
 export function buildPublic(options: TaskOptions) {
-    const folders = ['typescript'];
-    if (options.modulesSync){
-        for (const module of Object.keys(options.modulesSync)) {
-            folders.push(module);
-        }
-    }
+    const folders = ['typescript', ...options.modulesSourcePaths];
 
     const { outputDir } = options;
 

package/{src/gulp/styles.ts → src copy/gulp/styles.ts }

@@ -5,15 +5,10 @@ import { blue, orange, red } from '../index.js';
 
 export function compileScss(options: TaskOptions) {
     const folders = ['typescript'];
-    // if (options.modulesSync){
-    //     for (const module of Object.keys(options.modulesSync)) {
-    //         folders.push(module);
-    //     }
-    // }
 
     const { sass, outputDir} = options;
 
-    const buildWixScss =  () => gulp.src(['typescript/styles/global.scss'])
+    const buildWixScss =  () => gulp.src(['typescript/styles/global.scss'], { allowEmpty: true })
         .pipe(sass().on('error', sass.logError))
         .on('error', function (e: Error) {
             console.log("💩" + red.underline.bold(` => Build of SCSS files for ${orange('global.scs')} failed!`));
@@ -30,7 +25,7 @@ export function compileScss(options: TaskOptions) {
             console.log("🐶" + blue.underline(` => Compiling of scss files for ${orange('global.scs')} succeeded!`));
         });
 
-    const buildScss =  () => gulp.src(['typescript/public/scss/app.scss'])
+    const buildScss =  () => gulp.src(['typescript/public/scss/app.scss'], { allowEmpty: true })
         .pipe(sass().on('error', sass.logError))
         .on('error', function (e: Error) {
             console.log("💩" + red.underline.bold(` => Build of SCSS files for ${orange('app.scss')} failed!`));

package/{src/gulp/templates.ts → src copy/gulp/templates.ts }

@@ -4,12 +4,7 @@ import exec from 'gulp-exec';
 import { blue, orange, red } from '../index.js';
 
 export function previewTemplates(options: TaskOptions) {
-        const folders = ['typescript'];
-        if (options.modulesSync){
-            for (const module of Object.keys(options.modulesSync)) {
-                folders.push(module);
-            }
-        }
+        const folders = ['typescript', ...options.modulesSourcePaths];
         
         const taskOpt = {
             continueOnError: true,

package/src copy/helpers.ts

@@ -0,0 +1,307 @@
+import chalk from 'chalk';
+import { simpleGit, SimpleGit } from 'simple-git';
+import { spawnSync, exec } from 'child_process';
+// https://www.sergevandenoever.nl/run-gulp4-tasks-programatically-from-node/
+import path, { join } from 'path';
+import { fileURLToPath } from 'url';
+import { LucySettings, ModuleSettings, ProjectSettings } from '.';
+import os from 'os';
+import fs, { mkdirSync } from 'fs';
+import fse from 'fs-extra';
+import { writeFile } from 'fs/promises';
+
+import { blue, green, orange, red, yellow, magenta } from './index.js';
+
+export async function installPackages(wixPackages: Record<string, string>, devPackages: Record<string, string>,  cwd: string, locked: boolean ) {
+	if (locked) console.log("🐕" + blue.underline(` => Installing & version locked packages!`));
+
+	const wixPackageNames = Object.keys(wixPackages);
+	const wixPackageVersions = Object.values(wixPackages);
+	const wixPackageNamesAndVersions = wixPackageNames.map((name, index) => `${name}@${wixPackageVersions[index]}`);
+
+	const devPackageNames = Object.keys(devPackages);
+	const devPackageVersions = Object.values(devPackages);
+	const devPackageNamesAndVersions = devPackageNames.map((name, index) => `${name}@${devPackageVersions[index]}`);
+
+	let success = true;
+
+    // Dev packages are installed all at once with yarn.
+	if (devPackageNames.length > 0) {
+		console.log(`🐕 => Installing dev packages with yarn...`);
+		const packagesToInstall = locked ? devPackageNamesAndVersions.join(' ') : devPackageNames.join(' ');
+		const yarnAdd = `yarn add -D ${packagesToInstall}`;
+		const yarnRes = spawnSync(yarnAdd, { shell: true, stdio: 'inherit' });
+		if (yarnRes.error) {
+			success = false;
+			console.log((`💩 ${red.underline.bold("=> Failed to install dev packages =>")} ${orange(yarnRes.error.message)}`));
+		} else {
+			console.log("🐕" + blue.underline(` => Dev packages installed!`));
+		}
+	}
+
+	// Packages are installed all at once with yarn.
+    if (wixPackageNames.length > 0) {
+		console.log(`🐕 => Installing packages with yarn...`);
+		const packagesToInstall = locked ? wixPackageNamesAndVersions.join(' ') : wixPackageNames.join(' ');
+		const yarnAdd = `yarn add ${packagesToInstall}`;
+		const yarnRes = spawnSync(yarnAdd, { shell: true, stdio: 'inherit' });
+		if (yarnRes.error) {
+			success = false;
+			console.log((`💩 ${red.underline.bold("=> Failed to install packages =>")} ${orange(yarnRes.error.message)}`));
+		} else {
+			console.log("🐕" + blue.underline(` => Packages installed!`));
+		}
+	}
+
+	// Wix packages are installed one by one.
+	if (wixPackageNames.length > 0) {
+		wixPackageNames.forEach((name, index) => {
+			console.log(`🐕 => Installing wix package ${orange(name)}`);
+			const wixInstall = locked ? `wix install ${wixPackageNamesAndVersions[index]}`: `wix install ${name}`;
+			const wixres = spawnSync(wixInstall, { shell: true, stdio: 'inherit' });
+			if (wixres.error) {
+				console.log((`💩 ${red.underline.bold("=> Failed to install wix package =>")} ${orange(wixres.error.message)}`));
+				success = false;
+			} else {
+				console.log("🐕" + blue.underline(` => Wix package ${orange(name)} installed!`));
+			}
+		});
+	}
+
+	if(success) {
+		console.log("🐕" + blue.underline(` => All Packages installed!`));
+	} else {
+		console.log("🐕" + red.underline(` => Some packages failed to install!`));
+	}																
+}
+
+async function isSubmoduleRegistered(git: SimpleGit, submoduleName: string): Promise<boolean> {
+    try {
+        const urlConfig = await git.getConfig(`submodule.${submoduleName}.url`);
+        return !!urlConfig.value;
+    } catch (e) {
+        // simple-git throws an error if the config key doesn't exist
+        return false;
+    }
+}
+
+export async function gitInit(cwd: string, modules: LucySettings['modules'] | undefined, force: boolean) {
+	const git = simpleGit({ baseDir: cwd });
+
+    if (!(await git.checkIsRepo())) {
+        console.log(chalk.yellow('Project is not a git repository. Initializing...'));
+        await git.init();
+    }
+
+	if (!modules) {
+		console.log(chalk.yellow('No submodules defined in settings, skipping.'));
+		return;
+	}
+
+	const dotGitmodulesPath = path.join(cwd, '.gitmodules');
+
+	for (const [name, repo] of Object.entries(modules)) {
+		console.log(chalk.green.underline.bold(`Processing submodule ${name}`));
+		const clonePath = repo.path || name;
+
+		try {
+			const isRegistered = await isSubmoduleRegistered(git, clonePath);
+			// Check that .gitmodules exists AND contains the entry for this specific submodule.
+			const isConfiguredInFile = fs.existsSync(dotGitmodulesPath) &&
+				fs.readFileSync(dotGitmodulesPath, 'utf-8').includes(`[submodule "${clonePath}"]`);
+
+            // Add/repair if not configured in .gitmodules, or if forced by the user.
+            if (!isConfiguredInFile || force) {
+                console.log(`🐕 ${blue.underline(`Adding/updating submodule ${name} at ${clonePath}...`)}`);
+                // If git already has a config entry, we must use --force to repair it.
+                const submoduleArgs = ['add', ...(force || isRegistered ? ['--force'] : []), repo.url, clonePath];
+                await git.subModule(submoduleArgs);
+            } else {
+                console.log(`🐕 ${blue.underline(`Submodule ${name} at ${clonePath} already registered. Skipping add.`)}`);
+            }
+
+            await git.submoduleUpdate(['--init', '--recursive', clonePath]);
+            await simpleGit({ baseDir: path.join(cwd, clonePath) }).checkout(repo.branch);
+		} catch (err) {
+			console.log((`💩 ${red.underline.bold(`=> Command failed for submodule ${name} =>`)} ${orange(err)}`));
+		}
+	}
+	console.log("🐶" + green.underline(' => All modules processed!'));
+}
+
+
+export async function runGulp(moduleSettings: ModuleSettings, projectSettings: ProjectSettings, task: string) {
+    // Get the directory name of the current module
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+
+    // Resolve the path to the Gulpfile
+    const gulpfilePath = path.resolve(__dirname, 'Gulpfile.js');
+
+    // Dynamically import the Gulpfile
+    const gulpfile = await import(`file://${gulpfilePath}`);
+
+    // Check if 'dev' task exists
+    gulpfile.runTask(task, moduleSettings, projectSettings)
+}
+
+
+/**
+ * Clean up and run a command before exiting the process.
+ */
+export function cleanupWatchers() {
+    console.log(`🧹 ${magenta.underline('Cleaning up Watchman watchers...')}`);
+    const cwd = process.cwd();
+    const command = `watchman watch-del "${cwd}"`; // Adjust for Windows paths
+    exec(command, (error, stdout, stderr) => {
+        if (error) {
+            console.error(`💩 ${red.underline('Failed to run cleanup:')} ${orange(error.message)}`);
+            return;
+        }
+        if (stderr) {
+            console.error(`⚠️ ${yellow.underline('Watchman stderr:')} ${stderr}`);
+        }
+        console.log(`✅ ${green.underline('Watchman cleanup success:')} ${stdout}`);
+    });
+}
+
+/**
+ * Kill all processes matching a specific substring in their command, with a fallback for Windows.
+ * @param {string} processPattern - The substring to match (e.g., "wix:dev" or "@wix/cli/bin/wix.cjs").
+ */
+export function killAllProcesses(processPattern: string) {
+    const isWindows = os.platform() === 'win32';
+    const command = isWindows
+        ? `tasklist /FI "IMAGENAME eq node.exe" /FO CSV | findstr "${processPattern}"` // Adjust for Node.js processes
+        : `ps -eo pid,command | grep "${processPattern}" | grep -v grep`;
+
+    exec(command, (error, stdout, stderr) => {
+        if (error) {
+            console.error(`💩 ${red.underline('Failed to find processes:')} ${orange(error.message)}`);
+            return;
+        }
+        if (stderr) {
+            console.error(`⚠️ ${yellow.underline('Error output:')} ${stderr}`);
+        }
+        if (!stdout.trim()) {
+            console.log(`ℹ️ ${blue.underline(`No processes found matching pattern:`)} ${orange(processPattern)}`);
+            return;
+        }
+
+        console.log(`📝 ${magenta.underline('Found matching processes:')}\n${stdout}`);
+        const lines = stdout.trim().split('\n');
+        const pids = isWindows
+            ? lines.map(line => line.match(/"(\d+)"/)?.[1]) // Extract PID from Windows tasklist output
+            : lines.map(line => line.trim().split(/\s+/)[0]).filter(pid => !isNaN(Number(pid)));
+
+        pids.forEach(pid => {
+            if (!pid) return;
+            try {
+                const killCommand = isWindows
+                    ? `taskkill /PID ${pid} /T /F` // Forcefully terminate the process on Windows
+                    : `kill -SIGTERM ${pid}`;
+                
+                exec(killCommand, (killError) => {
+                    if (killError) {
+                        console.error(`⚠️ ${yellow.underline('Failed to kill process with PID')} ${orange(pid)}: ${red(killError.message)}`);
+                    } else {
+                        console.log(`✅ ${green.underline('Killed process with PID:')} ${orange(pid)}`);
+                    }
+                });
+
+                // Schedule SIGKILL fallback for non-Windows platforms
+                if (!isWindows) {
+                    setTimeout(() => {
+                        try {
+                            process.kill(parseInt(pid, 10), 'SIGKILL');
+                            console.log(`🔪 ${red.underline('Sent SIGKILL to process with PID:')} ${orange(pid)} (fallback).`);
+                        } catch (killError: any) {
+                            if (killError.code === 'ESRCH') {
+                                console.log(`✅ ${green.underline('Process with PID')} ${orange(pid)} ${green.underline('already terminated.')}`);
+                            } else {
+                                console.error(`⚠️ ${yellow.underline('Failed to send SIGKILL to process with PID')} ${orange(pid)}: ${red(killError.message)}`);
+                            }
+                        }
+                    }, 10000);
+                }
+            } catch (err: any) {
+                console.error(`⚠️ ${yellow.underline('Failed to kill process with PID')} ${orange(pid)}: ${red(err.message)}`);
+            }
+        });
+    });
+}
+
+export interface VeloSyncConfig {
+    siteUrl: string;
+    secret: string;
+}
+export async function saveConfig(config:VeloSyncConfig, file: string) {
+    await fs.promises.writeFile(file, JSON.stringify(config));
+}
+export async function readConfig(file: string): Promise<VeloSyncConfig> {
+    let content = await fs.promises.readFile(file, 'utf-8');
+    return JSON.parse(content);
+}
+
+export async function createTemplateFolder(moduleSettings: ModuleSettings) {
+        const templatesPath = join(os.homedir(), '.lucy-cli');
+    
+            try {
+            mkdirSync(templatesPath);
+
+            const defaultTemplatePath = join(templatesPath, 'default');
+            mkdirSync(defaultTemplatePath);
+
+            const sourceFilesPath = join(moduleSettings.packageRoot, 'files');
+            const defaultTemplateFilesPath = join(defaultTemplatePath, 'files');
+            await fse.copy(sourceFilesPath, defaultTemplateFilesPath);
+
+            const defaultTemplateSettingsPath = join(defaultTemplatePath, 'settings.json');
+            await writeFile(defaultTemplateSettingsPath, JSON.stringify(moduleSettings.settings, null, 2));
+
+            console.log(green('✅ Default template created successfully!'));
+        } catch (e) {
+            console.log((`💩 ${red.underline.bold("=> Error creating default template =>")} ${orange(e)}`));
+            return;
+        }
+}
+
+export type PackageJson = {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    [key: string]: any;
+}
+
+/**
+ * Updates a lucy.json file with dependencies from a package.json file.
+ * It replaces 'wixPackages' with 'dependencies' and 'devPackages' with 'devDependencies'.
+ * @param {string} packageJsonPath - Path to the package.json file.
+ * @param {string} lucyConfigPath - Path to the lucy.json file.
+ */
+export async function updateLucyConfigFromPackageJson(packageJsonPath: string, lucyConfigPath: string): Promise<void> {
+    try {
+        console.log(`🐕 Reading package definitions from ${orange(packageJsonPath)}...`);
+        const pkgJsonContent = await fs.promises.readFile(packageJsonPath, 'utf-8');
+        const packageJson: PackageJson = JSON.parse(pkgJsonContent);
+
+        console.log(`🐕 Reading Lucy configuration from ${orange(lucyConfigPath)}...`);
+        const lucyConfigContent = await fs.promises.readFile(lucyConfigPath, 'utf-8');
+        const lucyConfig: LucySettings = JSON.parse(lucyConfigContent);
+
+        const { dependencies = {}, devDependencies = {} } = packageJson;
+
+        // Note: `wixPackages` are installed using `wix install`. If your `dependencies`
+        // contain packages that are not Wix packages, `lucy-cli install` might fail.
+        lucyConfig.wixPackages = dependencies;
+        lucyConfig.devPackages = devDependencies;
+
+        console.log(`🐕 Writing updated configuration to ${orange(lucyConfigPath)}...`);
+        await fs.promises.writeFile(lucyConfigPath, JSON.stringify(lucyConfig, null, 2));
+
+        console.log(green.underline('✅ Lucy configuration updated successfully!'));
+
+    } catch (error: any) {
+        console.error(`💩 ${red.underline.bold('=> Error updating lucy.json from package.json:')} ${orange(error.message)}`);
+        throw error; // re-throw to allow caller to handle
+    }
+}