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

package/src/commands/install.ts

@@ -0,0 +1,249 @@
+import { Command } from "@effect/platform/index";
+import { Effect, Schedule } from "effect/index";
+import { Config } from "../config.js";
+import { logger } from "../utils/logger.js";
+import { CommandExecutor, ExitCode } from "@effect/platform/CommandExecutor";
+import { PlatformError } from "@effect/platform/Error";
+
+export const installPackages = (workspace: boolean = false) => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+
+        const pkgs: string[] = []
+        for (const [key, value] of Object.entries(config.config.lucySettings.dependencies)) {
+            if (value.length > 0) {
+                pkgs.push(`${key}@${value}`);
+                continue
+            }
+            pkgs.push(key);
+        }
+        const devPkgs: string[] = []
+        for (const [key, value] of Object.entries(config.config.lucySettings.devDependencies)) {
+            if (value.length > 0) {
+                devPkgs.push(`${key}@${value}`);
+                continue
+            }
+            devPkgs.push(key);
+        }
+
+        const manager = config.config.lucySettings.packageManager;
+        function pkgMgrParamsInstall():string[] {
+            if (manager === "npm") {
+                return ["install"];
+            }
+            if (manager === "pnpm") {
+                return ["install"];
+            }
+            return ["add"];
+        }
+        function pkgMgrParamsInstallDev():string[] {
+            if (manager === "npm") {
+                return ["install", "-D"];
+            }
+            if (manager === "pnpm") {
+                return ["install", "-D"];
+            }
+            return ["add", "-D"];
+        }
+
+        function workspaceEnabled() {
+            if(config.config.lucySettings.packageManager === "pnpm" && workspace) {
+                return ["--workspace-root"];
+            }
+            return [];
+        }
+        logger.info("Installing dependencies");
+
+        const install = Command.make(
+            manager,
+                ...pkgMgrParamsInstall(),
+                ...workspaceEnabled(),
+                ...pkgs,
+            ).pipe(
+            Command.stdout("inherit"), // Stream stdout to process.stdout
+            Command.stderr("inherit"), // Stream stderr to process.stderr
+            Command.exitCode // Get the exit code
+        )
+
+        logger.info("Installing dev dependencies");
+        const installDev = Command.make(
+                manager,
+                ...pkgMgrParamsInstallDev(),
+                ...workspaceEnabled(),
+                ...devPkgs,
+            ).pipe(
+            Command.stdout("inherit"), // Stream stdout to process.stdout
+            Command.stderr("inherit"), // Stream stderr to process.stderr
+            Command.exitCode // Get the exit code
+        )
+
+        if(Object.keys(config.config.lucySettings.dependencies).length > 0) {
+            if ((yield* install) !== 0) {
+                return logger.error("Failed to install dependencies. Please check the error message above.");
+            }
+        }
+        if(Object.keys(config.config.lucySettings.devDependencies).length > 0) {
+            if ((yield* installDev) !== 0) {
+                return logger.error("Failed to install dev dependencies. Please check the error message above.");
+            }
+        }
+    })
+}
+
+export const runInstall = Effect.gen(function*() {
+        const config = yield* Config;
+
+    const manager = config.config.lucySettings.packageManager;
+    const install = Command.make(
+        manager,
+        "install",
+    ).pipe(
+        Command.stdout("inherit"), // Stream stdout to process.stdout
+        Command.stderr("inherit"), // Stream stderr to process.stderr
+        Command.exitCode // Get the exit code
+    )
+    yield* install;
+})
+
+// export const yarnSetVersion = Effect.gen(function*() {
+//         const yarnDev = Command.make(
+//             "yarn",
+//             "set",
+//             "version",
+//             "berry",
+//         ).pipe(
+//         Command.stdout("inherit"), // Stream stdout to process.stdout
+//         Command.exitCode // Get the exit code
+//     )
+//     yield* yarnDev;
+// })
+export const installVeloPackages = Effect.gen(function*() {
+    const config = yield* Config;
+        const simpleSchedule = Schedule.tapOutput(
+            Schedule.fromDelays(50, 100, 200, 400, 800, 1600, 3200),
+            (n, ) => Effect.succeed(logger.warning(`Failed to install WIX package. Retrying...`))
+        );
+
+    const pkgs: string[] = []
+    for (const [key, value] of Object.entries(config.config.lucySettings.dependencies)) {
+        if (value.length > 0) {
+            pkgs.push(`${key}@${value}`);
+            continue
+        }
+        pkgs.push(key);
+    }
+
+    const wixPkgs: Effect.Effect<ExitCode, PlatformError, CommandExecutor>[] = []
+    const wixInstall = (cmd: Effect.Effect<ExitCode, PlatformError, CommandExecutor>) => Effect.gen(function*() {
+        const code = yield* Effect.retryOrElse(
+            Effect.gen(function*() {
+                const code = yield* cmd;
+                if (code !== 0) {
+                    return yield* Effect.fail(code);
+                }
+                return yield* Effect.succeed(code);
+            }), 
+            simpleSchedule,
+            () => Effect.succeed(0 as ExitCode)
+        )
+        if (code !== 0) {
+            logger.error("Failed to install WIX package.");
+        } 
+        return code;
+    })
+
+    for (const [key, value] of Object.entries(config.config.lucySettings.dependencies)) {
+        if (value.length > 0) {
+            wixPkgs.push(
+                wixInstall(
+                    Command.make(
+                        "wix",
+                        "install",
+                        `${key}@${value}`
+                ).pipe(
+                    Command.stdout("inherit"),
+                    Command.stderr("inherit"),
+                    Command.exitCode
+                )
+            )
+        )
+            continue
+        }
+        wixPkgs.push(
+            wixInstall(
+                Command.make(
+                    "wix",
+                    "install",
+                    `${key}`
+            ).pipe(
+                Command.stdout("inherit"),
+                Command.stderr("inherit"),
+                Command.exitCode
+            ),
+        ))
+    }
+
+    const devPkgs: string[] = []
+    for (const [key, value] of Object.entries(config.config.lucySettings.devDependencies)) {
+        if (value.length > 0) {
+            devPkgs.push(`${key}@${value}`);
+            continue
+        }
+        devPkgs.push(key);
+    }
+
+    const yarn = Command.make(
+            "yarn",
+            "add",
+            ...pkgs,
+        ).pipe(
+        Command.stdout("inherit"), // Stream stdout to process.stdout
+        Command.exitCode // Get the exit code
+    )
+    const yarnDev = Command.make(
+            "yarn",
+            "add",
+            "-D",
+            ...devPkgs,
+        ).pipe(
+        Command.stdout("inherit"), // Stream stdout to process.stdout
+        Command.exitCode // Get the exit code
+    )
+
+    logger.info("Installing dependencies with wix...");
+    const status = yield* Effect.all([...wixPkgs], { concurrency: 15});
+    if(status.every((s) => s !== 0)) {
+        return logger.error("Failed to install WIX dependencies. Please check the error message above.");
+    }
+
+    logger.info("Installing dependencies");
+    if ((yield* yarn) !== 0) {
+        return logger.error("Failed to install dependencies. Please check the error message above.");
+    }
+
+    logger.info("Installing dev dependencies");
+    if ((yield* yarnDev) !== 0) {
+        return logger.error("Failed to install dev dependencies. Please check the error message above.");
+    }
+
+})
+
+export const approveBuilds = Effect.gen(function*() {
+        const config = yield* Config;
+
+    const manager = config.config.lucySettings.packageManager;
+    const approve = Command.make(
+        "pnpm",
+        "approve-builds",
+    ).pipe(
+        Command.stdout("inherit"), // Stream stdout to process.stdout
+        Command.stderr("inherit"), // Stream stderr to process.stderr
+        Command.stdin("inherit"),
+        Command.exitCode // Get the exit code
+    )
+    if (manager !== "pnpm") {
+        logger.warning("The 'approve-build' command is only available for pnpm. Skipping...");
+        return;
+    }
+    yield* approve;
+})

package/src/commands/read.ts

@@ -0,0 +1,45 @@
+import { Effect, Schema } from "effect/index";
+import { FileSystem, Path } from "@effect/platform"
+import { Config, lucyJsonName, packageJsonPath, veloSyncJsonPath } from "../config.js";
+import { JsonSchema, veloSyncSettings } from "../schemas/index.js";
+import { lucySettings } from "../schemas/lucy.js";
+import { logger } from "../utils/logger.js";
+
+export const readPackageJson = Effect.gen(function* () {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+
+    const packageJsonRaw = yield* fs.readFile(packageJsonPath)
+    config.config.packageJson = yield* Schema.decodeUnknown(JsonSchema)(packageJsonRaw.toString());
+})
+
+export const readLucyJsonFromTemplate = Effect.gen(function* () {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    
+    const lucyRaw = yield* fs.readFileString(path.join(config.config.templateDir, lucyJsonName));   
+    const lucySettingsJSON = yield* Schema.decodeUnknown(JsonSchema)(lucyRaw); 
+    const lucySetting = yield* Schema.decodeUnknown(lucySettings)(lucySettingsJSON)
+
+    if(config.config.lucySettings.initialized) {
+        if(config.config.force) {
+            logger.warning(`${lucyJsonName} already exists in the target directory, but 'force' is set. Overwriting...`);
+            config.config.lucySettings = lucySetting;
+            return;
+        }
+        logger.warning(`${lucyJsonName} already exists in the target directory. Skipping reading ${lucyJsonName} from template.`);
+        return;
+    }
+    config.config.lucySettings = lucySetting;
+})
+
+export const readVeloSyncSettings = Effect.gen(function* ()   {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem;
+    if (yield* fs.exists(veloSyncJsonPath)) {
+        const snyConfigRaw = yield* fs.readFileString(veloSyncJsonPath)
+        config.config.veloSyncSettings = yield* Schema.decodeUnknown(veloSyncSettings)(snyConfigRaw);
+    }
+});

package/src/commands/write.ts

@@ -0,0 +1,45 @@
+import { Effect } from "effect/index";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { Config, lucyJsonPath, packageJsonPath, veloSyncJsonPath, wixSDKSettingsJsonPath } from "../config.js";
+
+export const writeLucySettings = Effect.gen(function* (_) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const config = yield* Config;
+    
+    yield* fs.writeFileString(
+        lucyJsonPath,
+        JSON.stringify(config.config.lucySettings, null, 2)
+    );
+})
+
+export const writePackageJson = Effect.gen(function* (_) {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const config = yield* Config;
+    yield* fs.writeFileString(
+        packageJsonPath,
+        JSON.stringify(config.config.packageJson, null, 2)
+    );
+})
+
+export const writeVeloSyncSettings = Effect.gen(function* ()   {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    yield* fs.writeFileString(
+        veloSyncJsonPath,
+        JSON.stringify(config.config.veloSyncSettings, null, 2)
+    );
+});
+
+export const writeWixSDKSettings = Effect.gen(function* ()   {
+    const config = yield* Config;
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    yield* fs.writeFileString(
+        wixSDKSettingsJsonPath,
+        JSON.stringify(config.config.wixSDKSettings, null, 2)
+    );
+});
+

package/src/config.ts

@@ -1,23 +1,37 @@
-import { Context, Layer } from "effect"
+import { Context, Effect, Layer, Schema } from "effect"
 import { get_args } from "./args.js";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
-import { readFileSync, existsSync } from "fs";
-type Action = 'init';
+import { lucySettings, LucySettings } from "./schemas/lucy.js";
+import os from 'os';
+import { Actions } from "./schemas/types.js";
+import { JsonSchema, veloSyncSettings, VeloSyncSettings, WixSDKSettings, wixSDKSettings } from "./schemas/index.js";
+import { FileSystem, Path } from "@effect/platform"
+import { NodeContext } from "@effect/platform-node/index";
 
-type Actions = {
-    action: Action;
-    type: 'velo' | 'expo' | 'blocks' | undefined;
-}
 export class Config extends Context.Tag("Config")<
     Config,
     {
         readonly config: {
             readonly action: Actions;
+            readonly force: boolean;
             readonly cwd: string;
             readonly packageRoot: string;
             readonly filesFolder: string;
-            readonly packageJson: any;
+            readonly veloSyncArguments?:{
+                    data?: string;
+                    collection?: string;
+                    schema?: string;
+                    dry: boolean;    
+            }
+            packageJson: any;
+            lucySettings: LucySettings;
+            readonly lucyHome: string;
+            templateDir: string;
+            templateFiles: string;
+            projectName: string;
+            veloSyncSettings?: VeloSyncSettings;
+            wixSDKSettings?: WixSDKSettings;
         }
     }
 >() {}
@@ -26,36 +40,103 @@ export class Config extends Context.Tag("Config")<
 // We can replicate it using `import.meta.url`.
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-
-// Assuming your compiled output is in a 'dist' folder at the project root,
-// and your source `config.ts` is in `src`, the running `config.js` will be
-// in something like `dist/src`. To get to the package root, we go up two levels.
 const packageRoot = join(__dirname, "..");
 
+export const packageJsonName = "package.json";
+export const lucyJsonName = "lucy.json";
+export const wixSyncJsonName = "wix-sync.json";
+export const wixSDKSettingsJsonName = "wix-sdk-settings.json";
+export const syncDataName = 'sync-data';
+export const packageJsonPath = join(process.cwd(), packageJsonName);
+export const lucyJsonPath = join(process.cwd(), lucyJsonName);
+export const veloSyncJsonPath = join(process.cwd(), wixSyncJsonName);
+export const wixSDKSettingsJsonPath = join(process.cwd(), wixSDKSettingsJsonName);
+export const syncFilesSource= join(packageRoot, 'files', syncDataName);
+
+
 export const ConfigLayer = (args: Awaited<ReturnType<typeof get_args>>) => {
-    let packageJson = '{}';
-    const packageJsonPath = join(process.cwd(), 'package.json');
-    try {
-        if (existsSync(packageJsonPath)) {
-            const raw = readFileSync(packageJsonPath, 'utf-8');
-            packageJson = JSON.parse(raw);
-        }
-    } catch (error) {
-        console.error("Error reading package.json:", error);
-    }
-    return Layer.succeed(
+    return Layer.effect(
         Config,
-        Config.of({
-            config: {
-                action: {
-                    type: args.type,
-                    action: args._[0] as Action
-                },
-                cwd: process.cwd(),
-                packageRoot: packageRoot,
-                filesFolder: join(packageRoot, 'files'),
-                packageJson
+        Effect.gen(function* () {
+            const fs = yield* FileSystem.FileSystem;
+            const path = yield* Path.Path;
+            
+            let packageJson: any = {};
+            let lucyJson: LucySettings | undefined = undefined;
+            let veloSyncJson: VeloSyncSettings | undefined = undefined;
+            let wixSDKSettingsJson: WixSDKSettings | undefined = undefined;
+            // Read package.json
+            if (yield* fs.exists(packageJsonPath)) {
+                const raw = yield* fs.readFileString(packageJsonPath, 'utf-8');
+                packageJson = yield* Schema.decodeUnknown(JsonSchema)(raw);
+            }
+
+            // Read lucy.json
+            if (yield* fs.exists(lucyJsonPath)) {
+                const raw = yield* fs.readFileString(lucyJsonPath, 'utf-8');
+                const lucyJsonRaw = yield* Schema.decodeUnknown(JsonSchema)(raw);
+                lucyJson = yield* Schema.decodeUnknown(lucySettings)(lucyJsonRaw);
+            }
+
+            // Read wix-sync.json
+            if (yield* fs.exists(veloSyncJsonPath)) {
+                const raw = yield* fs.readFileString(veloSyncJsonPath, 'utf-8');
+                const veloSyncSettingsRaw = yield* Schema.decodeUnknown(JsonSchema)(raw);
+                veloSyncJson = yield* Schema.decodeUnknown(veloSyncSettings)(veloSyncSettingsRaw);
             }
-        })
+
+            // Read wix-sdk-settings.json
+            if (yield* fs.exists(wixSDKSettingsJsonPath)) {
+                const raw = yield* fs.readFileString(wixSDKSettingsJsonPath, 'utf-8');
+                const wixSDKSettingsRaw = yield* Schema.decodeUnknown(JsonSchema)(raw);
+                wixSDKSettingsJson = yield* Schema.decodeUnknown(wixSDKSettings)(wixSDKSettingsRaw);
+            }
+
+            const defaultModulePath = () => {
+                if (args.type === 'monorepo') {
+                    return 'packages';
+                }
+                return '';
+            };
+
+            return Config.of({
+                config: {
+                    action: {
+                        initType: args.initType,
+                        action: args._[0],
+                        tasksName: args.tasksName,
+                        syncAction: args.syncAction,
+                        wixSDKAction: args.wixSDKAction,
+                    },
+                    force: args.force === true ? true : false,
+                    cwd: process.cwd(),
+                    projectName: process.cwd().split('/').pop() || 'lucy-project',
+                    packageRoot,
+                    filesFolder: join(packageRoot, 'files'),
+                    packageJson,
+                    lucyHome: join(os.homedir(), '.lucy-cli'),
+                    veloSyncSettings: veloSyncJson,
+                    veloSyncArguments: {
+                        data: path.join(process.cwd(), args.input || ''),
+                        collection: args.collection,
+                        schema: path.join(process.cwd(), args.schema || ''),
+                        dry: args.d || false,
+                    },
+                    wixSDKSettings: wixSDKSettingsJson,
+                    lucySettings: lucyJson || {
+                        modules: {},
+                        devDependencies: {},
+                        dependencies: {},
+                        scripts: {},
+                        initialized: false,
+                        type: args.initType || 'velo',
+                        packageManager: 'npm',
+                        defaultModulePath: ''
+                    },
+                    templateFiles: '',
+                    templateDir: '',                    
+                }
+            });
+        }).pipe(Effect.provide(NodeContext.layer))
     );
-}
+}

package/src/error.ts

@@ -1,4 +1,3 @@
 import { Data } from "effect";
 
-export class AppError extends Data.TaggedError('AppError')<{cause: Error, message: string}> {}
-export class ScaleError extends Data.TaggedError('ScaleError')<{cause: Error, message: string}> {}
+export class AppError extends Data.TaggedError('AppError')<{cause: unknown, message: string}> {}

package/src/helpers.ts

@@ -1,3 +1,7 @@
+import os from 'os';
+import { spawnSync, exec } from 'child_process';
+import { logger } from './utils/logger.js';
+
 export function parse_error(error: unknown): Error {
     if (error instanceof Error) {
         return error;
@@ -6,4 +10,92 @@ export function parse_error(error: unknown): Error {
     } else {
         return new Error('Unknown error');
     }
+}
+
+
+/**
+ * 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}"`
+        : `ps -eo pid,command | grep "${processPattern}" | grep -v grep`;
+
+    logger.action(`Cleaning up processes...`);
+
+    const result = spawnSync(command, { shell: true, encoding: 'utf-8' });
+
+    if (result.error) {
+        logger.error(`spawnSync error: ${result.error.message}`);
+        return;
+    }
+    // if (!result.stdout.trim()) {
+    //     logger.info(`No processes found matching pattern: ${processPattern}`);
+    //     return;
+    // }
+
+    const lines = result.stdout.trim().split('\n');
+    const pids = isWindows
+        ? lines.map(line => line.match(/"(\d+)"/)?.[1])
+        : lines.map(line => line.trim().split(/\s+/)[0]).filter(pid => !isNaN(Number(pid)));
+
+    logger.action(`Extracted PIDs: ${JSON.stringify(pids)}`);
+
+    pids.forEach(pid => {
+        if (!pid) return;
+        try {
+            const killCommand = isWindows
+                ? `taskkill /PID ${pid} /T /F`
+                : `kill -9 ${pid}`;
+
+            logger.info(`Running kill command: ${killCommand}`);
+
+            const killResult = spawnSync(killCommand, { shell: true, encoding: 'utf-8' });
+            if (killResult.error) {
+                logger.error(`Failed to kill process with PID ${pid}: ${killResult.error.message}`);
+            } else {
+                logger.success(`Killed process with PID: ${pid}`);
+            }
+
+            if (!isWindows) {
+                setTimeout(() => {
+                    try {
+                        process.kill(parseInt(pid, 10), 'SIGKILL');
+                        logger.info(`Sent SIGKILL to process with PID: ${pid}`);
+                    } catch (killError: any) {
+                        if (killError.code === 'ESRCH') {
+                            logger.info(`Process with PID ${pid} already terminated.`);
+                        } else {
+                            logger.error(`Failed to send SIGKILL to process with PID ${pid}: ${killError.message}`);
+                        }
+                    }
+                }, 10000);
+            }
+        } catch (err: any) {
+            logger.error(`Failed to kill process with PID ${pid}: ${err.message}`);
+        }
+    });
+}
+
+/**
+ * Clean up and run a command before exiting the process.
+ */
+export function cleanupWatchers() {
+    logger.info(`🧹 Cleaning up Watchman watchers...`);
+    const cwd = process.cwd();
+    const command = `watchman watch-del "${cwd}"`; // Adjust for Windows paths
+
+    logger.info(`Cleaning watchers for directory: ${cwd}`);
+    const result = spawnSync(command, { shell: true, encoding: 'utf-8' });
+
+    // if (result.stderr) {
+    //     logger.error(`spawnSync error: ${result.stderr}`);
+    //     return;
+    // }
+    // if (!result.stdout.trim()) {
+    //     logger.info(`No watchers found to clean up.`);
+    //     return;
+    // }
 }