lucy-cli 1.2.5 → 2.0.0-alpha.10

package/dist/args.d.ts

@@ -0,0 +1,7 @@
+export interface LucyArgs {
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+    type?: 'velo' | 'expo' | 'blocks';
+}
+export declare function get_args(): Promise<LucyArgs>;

package/dist/args.js

@@ -0,0 +1,23 @@
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+export async function get_args() {
+    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', {
+            describe: 'The type of project to initialize',
+            choices: ['velo', 'expo', 'blocks'],
+            demandOption: true, // Makes this positional argument required
+        });
+    })
+        // 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.')
+        .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
+        .parseAsync();
+    // The cast is now safer with the defined interface.
+    return argv;
+}

package/dist/commands.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from "effect";
+import { AppError } from "./error.js";
+export declare const init_expo: () => Effect.Effect<void, AppError, never>;

package/dist/commands.js

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { exec as execCallback } from "child_process";
+import { AppError } from "./error.js";
+import { parse_error } from "./helpers.js";
+import { promisify } from 'util';
+import { default_docker_retry } from "./policy.js";
+const exec = promisify(execCallback);
+export const init_expo = () => Effect.gen(function* () {
+    const format = "{{.ID}}\\t{{.Name}}\\t{{.Mode}}\\t{{.Replicas}}\\t{{.Image}}\\t{{.Ports}}";
+    const command = `docker service ls --format "${format}"`;
+    const res = yield* Effect.retry(Effect.tryPromise({
+        try: () => exec(command, { encoding: 'utf8' }),
+        catch: (error) => new AppError({ cause: parse_error(error), message: "Error getting services" })
+    }), default_docker_retry);
+    if (res.stderr) {
+        yield* Effect.logError(`Command "${command}" produced stderr: ${res.stderr}`);
+    }
+});

package/dist/config.d.ts

@@ -0,0 +1,20 @@
+import { Context, Layer } from "effect";
+import { get_args } from "./args.js";
+type Action = 'init';
+type Actions = {
+    action: Action;
+    type: 'velo' | 'expo' | 'blocks' | undefined;
+};
+declare const Config_base: Context.TagClass<Config, "Config", {
+    readonly config: {
+        readonly action: Actions;
+        readonly cwd: string;
+        readonly packageRoot: string;
+        readonly filesFolder: string;
+        readonly packageJson: any;
+    };
+}>;
+export declare class Config extends Config_base {
+}
+export declare const ConfigLayer: (args: Awaited<ReturnType<typeof get_args>>) => Layer.Layer<Config, never, never>;
+export {};

package/dist/config.js

@@ -0,0 +1,39 @@
+import { Context, Layer } from "effect";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { readFileSync, existsSync } from "fs";
+export class Config extends Context.Tag("Config")() {
+}
+// In an ES module, `__dirname` is not available by default.
+// 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 ConfigLayer = (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(Config, Config.of({
+        config: {
+            action: {
+                type: args.type,
+                action: args._[0]
+            },
+            cwd: process.cwd(),
+            packageRoot: packageRoot,
+            filesFolder: join(packageRoot, 'files'),
+            packageJson
+        }
+    }));
+};

package/dist/error.d.ts

@@ -0,0 +1,17 @@
+declare const AppError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "AppError";
+} & Readonly<A>;
+export declare class AppError extends AppError_base<{
+    cause: Error;
+    message: string;
+}> {
+}
+declare const ScaleError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ScaleError";
+} & Readonly<A>;
+export declare class ScaleError extends ScaleError_base<{
+    cause: Error;
+    message: string;
+}> {
+}
+export {};

package/dist/error.js

@@ -0,0 +1,5 @@
+import { Data } from "effect";
+export class AppError extends Data.TaggedError('AppError') {
+}
+export class ScaleError extends Data.TaggedError('ScaleError') {
+}

package/dist/helpers.d.ts

@@ -1,32 +1 @@
-import { LucySettings, ModuleSettings, ProjectSettings } from '.';
-export declare function installPackages(wixPackages: Record<string, string>, devPackages: Record<string, string>, cwd: string, locked: boolean): Promise<void>;
-export declare function gitInit(cwd: string, modules: LucySettings['modules'] | undefined, force: boolean): Promise<void>;
-export declare function runGulp(moduleSettings: ModuleSettings, projectSettings: ProjectSettings, task: string): Promise<void>;
-/**
- * Clean up and run a command before exiting the process.
- */
-export declare function cleanupWatchers(): void;
-/**
- * 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 declare function killAllProcesses(processPattern: string): void;
-export interface VeloSyncConfig {
-    siteUrl: string;
-    secret: string;
-}
-export declare function saveConfig(config: VeloSyncConfig, file: string): Promise<void>;
-export declare function readConfig(file: string): Promise<VeloSyncConfig>;
-export declare function createTemplateFolder(moduleSettings: ModuleSettings): Promise<void>;
-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 declare function updateLucyConfigFromPackageJson(packageJsonPath: string, lucyConfigPath: string): Promise<void>;
+export declare function parse_error(error: unknown): Error;

package/dist/helpers.js

@@ -1,266 +1,11 @@
-import chalk from 'chalk';
-import { 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 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, devPackages, cwd, locked) {
-    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!`));
-        }
+export function parse_error(error) {
+    if (error instanceof Error) {
+        return error;
     }
-    // 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 if (typeof error === 'string') {
+        return new Error(error);
     }
     else {
-        console.log("🐕" + red.underline(` => Some packages failed to install!`));
-    }
-}
-async function isSubmoduleRegistered(git, submoduleName) {
-    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, modules, force) {
-    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, projectSettings, task) {
-    // 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) {
-    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) {
-                            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) {
-                console.error(`⚠️ ${yellow.underline('Failed to kill process with PID')} ${orange(pid)}: ${red(err.message)}`);
-            }
-        });
-    });
-}
-export async function saveConfig(config, file) {
-    await fs.promises.writeFile(file, JSON.stringify(config));
-}
-export async function readConfig(file) {
-    let content = await fs.promises.readFile(file, 'utf-8');
-    return JSON.parse(content);
-}
-export async function createTemplateFolder(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;
-    }
-}
-/**
- * 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, lucyConfigPath) {
-    try {
-        console.log(`🐕 Reading package definitions from ${orange(packageJsonPath)}...`);
-        const pkgJsonContent = await fs.promises.readFile(packageJsonPath, 'utf-8');
-        const packageJson = JSON.parse(pkgJsonContent);
-        console.log(`🐕 Reading Lucy configuration from ${orange(lucyConfigPath)}...`);
-        const lucyConfigContent = await fs.promises.readFile(lucyConfigPath, 'utf-8');
-        const lucyConfig = 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) {
-        console.error(`💩 ${red.underline.bold('=> Error updating lucy.json from package.json:')} ${orange(error.message)}`);
-        throw error; // re-throw to allow caller to handle
+        return new Error('Unknown error');
     }
 }

package/dist/index.d.ts

@@ -1,59 +1,2 @@
-#!/usr/bin/env node --no-warnings
-export type ModulesSettings = {
-    packageRoot: string;
-    targetFolder: string;
-    args: string[];
-    settings: LucySettings;
-};
-export type LucySettings = {
-    modules: {
-        [libName: string]: {
-            url: string;
-            branch: string;
-            path?: string;
-            noCompile?: boolean;
-        };
-    };
-    wixSettings: {
-        compilerOptions: {
-            composite: boolean;
-            noEmit: boolean;
-            lib: string[];
-            jsx: string;
-        };
-        exclude: string[];
-    };
-    initialized: boolean;
-    wixPackages: {
-        [packageName: string]: string;
-    };
-    devPackages: {
-        [packageName: string]: string;
-    };
-    scripts: {
-        [commandName: string]: string;
-    };
-};
-export type ModuleSettings = {
-    packageRoot: string;
-    targetFolder: string;
-    args: string[];
-    wixConfigPath: string;
-    lucyConfigPath: string;
-    packageJsonPath: string;
-    settings: LucySettings;
-    lockVersion: boolean;
-    force: boolean;
-    veloConfigName: string;
-};
-export type ProjectSettings = {
-    modules?: Record<string, string>;
-    lucySettings?: LucySettings;
-    packageJSON?: Record<string, any>;
-};
-export declare const orange: import("chalk").ChalkInstance;
-export declare const blue: import("chalk").ChalkInstance;
-export declare const green: import("chalk").ChalkInstance;
-export declare const red: import("chalk").ChalkInstance;
-export declare const yellow: import("chalk").ChalkInstance;
-export declare const magenta: import("chalk").ChalkInstance;
+#!/usr/bin/env node
+import 'dotenv/config';