lucy-cli 2.0.0-alpha.9 → 2.0.0-beta.2

package/src/args.ts

@@ -1,36 +1,122 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
+import { initTypes, LucyArgs, taskNames, syncActions } from "./schemas/types.js";
+import { createRequire } from "node:module";
 
-// It's a good practice to define an interface for your arguments
-// for type safety throughout your application.
-export interface LucyArgs {
-    [x: string]: unknown;
-    // This will hold the command used, e.g., 'init'
-    _: (string | number)[];
-    $0: string;
-    // Arguments for the 'init' command
-    type?: 'velo' | 'expo' | 'blocks';
-}
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
 
 export async function get_args(): Promise<LucyArgs> {
     const argv = await yargs(hideBin(process.argv))
         .usage('Usage: $0 <command> [options]')
-        .command('init <type>', 'Initialize a new Lucy project', (yargs) => {
-            return yargs.positional('type', {
+        .command('init <initType>', 'Initialize a new Lucy project', (yargs) => {
+            return yargs.positional('initType', {
                 describe: 'The type of project to initialize',
-                choices: ['velo', 'expo', 'blocks'] as const,
-                demandOption: true, // Makes this positional argument required
+                choices: initTypes,
+                demandOption: true,
+            })
+        }).option('force', {
+            alias: 'f',
+            type: 'boolean',
+            description: 'Run with force'
+        })
+        .command('open', 'Open the Lucy home directory')
+        .command('task <tasksName>', 'Run a task', (yargs) => {
+            return yargs.positional('tasksName', {
+                describe: 'The task to run',
+                choices: taskNames,
+                demandOption: true,
+            })
+        })
+        .command('wix-sync <syncAction>', 'Run a velo-sync action', (yargs) => {
+            return yargs.positional("syncAction", {
+                describe: "The velo-sync action to run",
+                choices: syncActions,
+                demandOption: true,
+            })
+            .option('input', {
+                alias: 'i',
+                type: 'string',
+                describe: 'The CSV file to import',
+                demandOption: false,
+            })
+            .option('c', {
+                alias: 'collection',
+                type: 'string',
+                describe: 'The name of the collection to import data into',
+                demandOption: false,
+            })
+            .option('s', {
+                alias: 'schema',
+                type: 'string',
+                describe: 'The schema file',
+                demandOption: false,
+            })
+            .option('d', {
+                type: 'boolean',
+                describe: 'Run in dry-run mode',
+                demandOption: false,
+            });
+        })
+        .command('wix-sdk <wixSDKAction>', 'Run a velo-sync action', (yargs) => {
+            return yargs.positional("wixSDKAction", {
+                describe: "The velo-sync action to run",
+                choices: syncActions,
+                demandOption: true,
             });
         })
-        // Enforce that a command must be provided (e.g., 'init')
         .demandCommand(1, 'You need to provide a command. Use --help for a list of commands.')
+        .version('v', 'Show version number', pkg.version)
+        .alias('v', 'version')
         .help()
         .alias('h', 'help')
         .strict()
-        .wrap(yargs().terminalWidth()) // Wrap help text to terminal width
-        .epilogue('For more information, visit https://github.com/your-repo/wix-lucy-cli') // Example of a relevant epilogue
+        .wrap(yargs().terminalWidth())
+        .epilogue(`
+🦮 Lucy CLI - Complete Command Overview
+
+📋 Available Commands:
+  init <type>        Initialize a new Lucy project (types: ${initTypes.join(', ')})
+  open               Open the Lucy home directory
+  task <name>        Run a task (tasks: ${taskNames.join(', ')})
+  wix-sync <action>  Run velo-sync actions (actions: ${syncActions.join(', ')})
+  wix-sdk <action>   Run Wix SDK actions
+
+🔧 Available Tasks:
+  dev                Start development environment
+  build              Build the project
+  build-prod         Build for production
+  build-pipeline     Build pipeline
+  sync-settings      Sync settings
+
+🔄 Wix Sync Actions:
+  sync               Synchronize collections
+  import             Import data from CSV
+  init               Initialize sync configuration
+  is-alive           Check if sync is alive
+  migrate            Migrate data
+  export             Export data
+
+⚙️ Global Options:
+  -h, --help         Show this help message
+  -v, --version      Show version number
+  -f, --force        Force execution (use with caution)
+
+📁 Project Types:
+  velo               Wix Velo project
+  expo               React Native with Expo
+  blocks             Wix Blocks
+  monorepo           Monorepo setup
+  tauri              Tauri desktop app
+  cargo              Rust project
+  submodules         Git submodules
+  wix-sdk            Wix SDK setup
+
+For more information, visit https://github.com/your-repo/wix-lucy-cli
+        `)
         .parseAsync();
 
     // The cast is now safer with the defined interface.
+    
     return argv as LucyArgs;
 }

package/src/commands/checks.ts

@@ -0,0 +1,51 @@
+import { Effect, Schema } from "effect/index";
+import { FileSystem, Path } from "@effect/platform"
+import { Config, lucyJsonName } from "../config.js";
+import { logger } from "../utils/logger.js";
+import { AppError } from "../error.js";
+import { JsonSchema } from "../schemas/index.js";
+
+export const isDirectoryClean =(excludes: string[] = []) => {
+    return Effect.gen(function*() {
+        const fs = yield* FileSystem.FileSystem;
+        const config = yield* Config;
+
+        const files = yield* fs.readDirectory(config.config.cwd);
+        const allExcludes = [...excludes, '.git', lucyJsonName];
+        const filteredFiles = files.filter(file => !allExcludes.includes(file));
+
+        return filteredFiles.length > 0 ? false : true;
+    });
+}
+
+export const checkForDirty = (excludes: string[] = []) => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const clean = yield* isDirectoryClean(excludes);
+        if(!clean && !config.config.force) {
+            logger.alert("The current directory is not empty. Please run this command in an empty directory.")
+            yield* Effect.fail(new AppError({ message: "Directory is not clean", cause: new Error("Directory is not clean") }));
+            return;
+        }
+        if(config.config.lucySettings.initialized && !config.config.force) {
+            logger.alert("Lucy is already initialized in this directory. Use --force to reinitialize.")
+            yield* Effect.fail(new AppError({ message: "Lucy is already initialized in this directory", cause: new Error("Lucy is already initialized in this directory") }));
+            return;
+        }
+
+        if ((!clean && config.config.force) || (config.config.lucySettings.initialized && config.config.force)) logger.alert("Forced initialization!")
+    });
+}
+export const checkForVelo = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+
+        const wixConfigPath = path.join(config.config.cwd, 'wix.config.json'); 
+        const wixConfigRaw = yield* fs.readFileString(wixConfigPath);
+        const wixConfigJSON =( yield* Schema.decodeUnknown(JsonSchema)(wixConfigRaw)) as any;
+
+        if(!(wixConfigJSON.siteId)) return yield* Effect.fail(new AppError({ message: "This directory is not a Velo project. Please run this command in a Velo project directory.", cause: new Error("Not a Velo project") }));
+    });
+}

package/src/commands/cleanup.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect/index";
+import { Config } from "../config.js";
+import { FileSystem, Path } from "@effect/platform"
+
+export const cleanup = Effect.gen(function* () {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+
+    yield* fs.remove(path.join(config.config.cwd, "package-lock.json"), { force: true })
+});

package/src/commands/copy.ts

@@ -0,0 +1,28 @@
+import { Effect } from "effect/index";
+import { Path } from "@effect/platform"
+import { FileSystem } from "@effect/platform"
+import { Config, syncDataName, syncFilesSource } from "../config.js";
+
+export const copyTemplateFiles = Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const config = yield* Config;
+    const path = yield * Path.Path;
+
+    const templateFiles = yield* fs.readDirectory(config.config.templateFiles)
+    yield* Effect.forEach(
+        templateFiles,
+        (file) => fs.copy(path.join(config.config.templateFiles, file), path.join(config.config.cwd, file), { overwrite: true })
+    )
+})
+export const copySyncFiles = Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const config = yield* Config;
+    const path = yield * Path.Path;
+
+    const synDataFiles = yield* fs.readDirectory(syncFilesSource)
+    yield* fs.makeDirectory(path.join(config.config.cwd, syncDataName));
+    yield* Effect.forEach(
+        synDataFiles,
+        (file) => fs.copy(path.join(syncFilesSource, file), path.join(config.config.cwd, syncDataName, file), { overwrite: true })
+    )
+})

package/src/commands/edit.ts

@@ -0,0 +1,81 @@
+import { Effect, Schema } from "effect/index";
+import { Config, lucyJsonPath } from "../config.js";
+import { FileSystem, Path } from "@effect/platform"
+import { logger } from "../utils/logger.js";
+import { JsonSchema } from "../schemas/index.js";
+import { LucySettings } from "../schemas/lucy.js";
+
+export const editJson = (json: any, keys: string[], values: string[] | Object[]) => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+
+        for (const key of keys){
+			const index = keys.indexOf(key);
+			const value = values[index];
+			json[key] = value;
+		}
+    })
+}
+
+export const mergeLucySettings2PackageJson = Effect.gen(function*() {
+    const config = yield* Config;
+    const lucySettings = config.config.lucySettings;
+    const packageJson = config.config.packageJson;
+
+    if (Object.keys(lucySettings.scripts).length > 0) {
+        yield* editJson(packageJson, ['scripts'], [{...packageJson.scripts, ...lucySettings.scripts}]);
+    }
+})
+
+export const setModule = Effect.gen(function*() {
+    const config = yield* Config;
+    const lucySettings = config.config.lucySettings;
+    const packageJson = config.config.packageJson;
+
+	yield* editJson(packageJson, ['type'], ['module']);
+})
+
+export const mergeAdditions = Effect.gen(function*() {
+    const config = yield* Config;
+    const lucySettings = config.config.lucySettings;
+    const packageJson = config.config.packageJson;
+
+	config.config.packageJson = {
+        ...packageJson,
+        ...lucySettings.additionalPkgProps,
+    }
+})
+
+export const setProjectName = Effect.gen(function*() {
+    const config = yield* Config;
+    const packageJson = config.config.packageJson;
+
+	yield * editJson(packageJson, ["name"], [config.config.projectName]);
+})
+
+export const setInitialized = Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem;
+    const lucyRaw = yield* fs.readFileString(lucyJsonPath);
+    const lucyJSON = (yield* Schema.decodeUnknown(JsonSchema)(lucyRaw)) as any;
+    lucyJSON.initialized = true;
+
+    yield* fs.writeFileString(lucyJsonPath, JSON.stringify(lucyJSON, null, 2));
+})
+
+export const stringReplace = (filePath: string, keys: string[], values: string[]) => {
+    return Effect.gen(function*() {
+        const fs = yield* FileSystem.FileSystem;
+        let modifiedContent: string = '';
+
+        logger.action(`Replacing ${keys} with ${values} in ${filePath}`);
+        const data = yield* fs.readFileString(filePath, 'utf8');
+        for (const key of keys){
+			const index = keys.indexOf(key);
+			const value = values[index];
+			const regex = new RegExp(`${key}`, 'g');
+			modifiedContent = data.replace(regex, `${value}`);
+		}
+        yield* fs.writeFileString(filePath, modifiedContent);
+        logger.info(`Updated file ${filePath}`);
+    })
+}

package/src/commands/exec.ts

@@ -0,0 +1,69 @@
+import { Effect, Schema } from "effect/index";
+import { Config } from "../config.js";
+import { Command } from "@effect/platform/index";
+import { logger } from "../utils/logger.js";
+import { FileSystem } from "@effect/platform"
+import Enquirer from "enquirer";
+import { AppError } from "../error.js";
+
+export const execCommand = Effect.gen(function*() {
+    const config = yield* Config;
+    const cmds = config.config.lucySettings.additionalCommands ?? [];
+    logger.info("Executing additional commands...", cmds);
+    if (cmds.length > 0) {
+        logger.info("Executing additional commands");
+      yield *
+        Effect.all([
+            ...cmds.map((cmd) => {
+            return Command.make(cmd[0], ...cmd.slice(1))
+                .pipe()
+                .pipe(Command.stdout("inherit"), Command.stderr("inherit"), Command.exitCode);
+            }),
+        ]);
+    }
+})
+
+export const open = Effect.scoped(Effect.gen(function*() {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem
+    console.log("Opening Lucy home directory:", config.config.lucyHome);
+    let command: ReturnType<typeof Command.make>;
+    switch (process.platform) {
+        case 'darwin': command = Command.make('open', config.config.lucyHome); break;
+        case 'win32': command = Command.make('start', config.config.lucyHome); break;
+        default: command = Command.make('xdg-open', config.config.lucyHome); break;
+    }
+
+    command.pipe().pipe(Command.stdout("inherit"), Command.stderr("inherit"), Command.exitCode);
+    yield* command.pipe().pipe(Command.stdout("inherit"), Command.stderr("inherit"), Command.exitCode);
+}))
+
+export const openVSCode = Effect.gen(function*() {
+    const config = yield* Config;
+    const open = Command.make(
+        "code", 
+        config.config.cwd,
+        ).pipe(
+        Command.stdout("inherit"), // Stream stdout to process.stdout
+        Command.stderr("inherit"), // Stream stderr to process.stderr
+        Command.exitCode // Get the exit code
+    )
+    const overwriteQuestion = new Enquirer();
+    const openVScodeQuestion = yield* Effect.tryPromise({
+        try: () => overwriteQuestion.prompt({
+            type: 'confirm',
+            name: 'openVSCode',
+            message: `Do you want to open the project in VSCode?`,
+        }),
+        catch: (e) => {
+            return new AppError({
+                cause: e,
+                message: "Error opening VSCode",
+            });
+        }
+    })
+    const choice = yield* Schema.decodeUnknown(Schema.Struct({ openVSCode: Schema.Boolean }))(openVScodeQuestion);
+    if (choice.openVSCode) {
+        yield* open
+    }
+})

package/src/commands/git.ts

@@ -0,0 +1,113 @@
+import { Effect } from 'effect/index';
+import { simpleGit, SimpleGit } from 'simple-git';
+import { Config } from '../config.js';
+import { AppError } from '../error.js';
+import { logger } from '../utils/logger.js';
+import { FileSystem, Path } from "@effect/platform"
+
+export const isSubmoduleRegistered = (git: SimpleGit, submoduleName: string) => Effect.gen(function* () {
+    const value = yield* Effect.tryPromise({
+        try: () => git.getConfig(`submodule.${submoduleName}.url`),
+        catch: (error) => {
+            return new AppError({
+                cause: error,
+                message: "Failed to get submodule url",
+            });
+        }
+    })
+    return !!value.value;
+})
+
+export const gitInit = (update: boolean = false) => Effect.gen(function* () {
+    const config = yield* Config;
+    const git = simpleGit({ baseDir: config.config.cwd });
+    const path = yield * Path.Path;
+
+    const isGit = yield* Effect.tryPromise({
+        try: () => git.checkIsRepo(),
+        catch: (error) => {
+            return new AppError({
+                cause: error,
+                message: "Failed to check if the directory is a git repository",
+            });
+        }
+    })
+
+    if(!isGit) {
+        yield* Effect.tryPromise({
+            try: () => git.init(),
+            catch: (error) => {
+                return new AppError({
+                    cause: error,
+                    message: "Failed to initialize git repository",
+                });
+            }
+        })
+    }
+
+    if (!config.config.lucySettings.modules) {
+        logger.alert('No submodules defined in settings, skipping.');
+		return;
+	}
+    yield* initSubmodules(update);
+})
+
+export const initSubmodules = (update: boolean = false) => Effect.gen(function* () {
+    const config = yield* Config;
+    const git = simpleGit({ baseDir: config.config.cwd });
+    const path = yield* Path.Path;
+    const fs = yield* FileSystem.FileSystem;
+    const gitmodulesPath = path.join(config.config.cwd, ".gitmodules");
+
+    for (const [name, repo] of Object.entries(config.config.lucySettings.modules)) {
+        logger.action(`Processing submodule ${name}`);
+		const clonePath = repo.path || path.join(config.config.lucySettings.defaultModulePath ?? '', name);
+
+        const isRegistered = yield* isSubmoduleRegistered(git, clonePath);
+        const isConfiguredInFile = (yield* fs.exists(gitmodulesPath)) && (yield* fs.readFileString(gitmodulesPath, 'utf-8')).includes(`[submodule "${clonePath}"]`);
+
+        if (!isConfiguredInFile || config.config.force) {
+            logger.action(`Adding/updating submodule ${name} at ${clonePath}...`);
+            // If git already has a config entry, we must use --force to repair it.
+            const submoduleArgs = () => {
+                if (update) {
+                    return ['add', '--force', repo.source, clonePath];
+                }
+                return ['add', ...(config.config.force || isRegistered ? ['--force'] : []), repo.source, clonePath];
+            }
+            // await git.subModule(submoduleArgs);
+            yield* Effect.tryPromise({
+                try: () => git.subModule(submoduleArgs()),
+                catch: (error) => {
+                    return new AppError({
+                        cause: error,
+                        message: "Failed to add submodule",
+                    });
+                }
+            })
+        } else {
+            logger.alert(`Submodule ${name} at ${clonePath} already registered. Skipping add.`);
+        }
+
+        yield* Effect.tryPromise({
+            try: () => git.submoduleUpdate(['--init', '--recursive', clonePath]),
+            catch: (error) => {
+                return new AppError({
+                    cause: error,
+                    message: "Failed to update submodule",
+                });
+            }
+        })
+        yield* Effect.tryPromise({
+            try: () => simpleGit({ baseDir: path.join(config.config.cwd, clonePath) }).checkout(repo.branch),
+            catch: (error) => {
+                return new AppError({
+                    cause: error,
+                    message: `Failed to checkout submodule ${repo} branch ${repo.branch}`,
+                });
+            }
+        })
+    }
+    logger.success("All modules processed!");
+
+})

package/src/commands/home.ts

@@ -0,0 +1,22 @@
+import { Effect } from "effect/index";
+import { Config } from "../config.js";
+import { FileSystem } from "@effect/platform"
+import { logger, orange } from "../utils/logger.js";
+import path, { join } from 'path';
+
+export const createLucyHome = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config
+        const fs = yield* FileSystem.FileSystem
+
+        if(!(yield* fs.exists(config.config.lucyHome))) {
+            logger.action(`Creating Lucy home directory at ${orange(config.config.lucyHome)}`);
+            yield* fs.makeDirectory(config.config.lucyHome, { recursive: true });
+        }
+        const templateFiles = yield* fs.readDirectory(config.config.filesFolder)
+        yield* Effect.forEach(
+            templateFiles,
+            (file) => fs.copy(path.join(config.config.filesFolder, file), path.join(config.config.lucyHome, file), { overwrite: true })
+        )
+    });
+}