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

package/src/init/index.ts

@@ -0,0 +1,81 @@
+import { Effect, Schema } from "effect/index"
+import { Config } from "../config.js";
+import { init_expo } from "./expo.js";
+import { selectTemplate } from "./templates.js";
+import Enquirer from "enquirer";
+import { AppError } from "../error.js";
+import { createLucyHome } from "../commands/home.js";
+import { readLucyJsonFromTemplate } from "../commands/read.js";
+import { init_monorepo } from "./monorepo.js";
+import { init_cargo } from "./cargo.js";
+import { init_blocks } from "./blocks.js";
+import { init_velo } from "./velo.js";
+import { init_submodules } from "./gitModules.js";
+import { init_tauri } from "./tauri.js";
+import { pkgManagers } from "../schemas/lucy.js";
+
+
+export const init = Effect.gen(function* (_) {
+    const config = yield* Config;
+    if(config.config.action.initType === undefined) {
+        return yield* Effect.fail(new AppError({ message: "No init type provided", cause: new Error("No init type provided") }));
+    }
+    yield* createLucyHome();
+    const projectName = config.config.cwd.split('/').pop() || 'expo-project';
+    const templateQuestion = new Enquirer();
+    const choice = yield* Effect.tryPromise({
+        try: () => templateQuestion.prompt({
+            type: 'input',
+            name: 'projectName',
+            message: 'Enter a project name',
+            initial: projectName,
+            validate: (value: string) => value.trim() !== '' ? true : 'Project name cannot be empty'
+        }),
+        catch: (e) => {
+            return new AppError({ cause: e, message: 'Error selecting template' });
+        }
+    })
+    const selectedName = yield* Schema.decodeUnknown(Schema.Struct({ projectName: Schema.String }))(choice)
+    config.config.projectName = selectedName.projectName.trim();
+    yield* selectTemplate();
+    yield* readLucyJsonFromTemplate;
+
+    const pkgMgrQuestion = new Enquirer();
+    const pkgMgr = yield* Effect.tryPromise({
+        try: () => pkgMgrQuestion.prompt({
+            type: 'select',
+            name: 'packageManager',
+            message: 'Select a package manager',
+            choices: [...pkgManagers],
+        }),
+        catch: (e) => {
+            return new AppError({ cause: e, message: 'Error selecting package manager' });
+        }
+    })
+    const selectedPkgMgr = yield* Schema.decodeUnknown(Schema.Struct({ packageManager: Schema.Literal(...pkgManagers) }))(pkgMgr)
+    config.config.lucySettings.packageManager = selectedPkgMgr.packageManager;
+    
+
+    if(config.config.action.initType === 'expo') {
+        return yield* init_expo();
+    }
+    if(config.config.action.initType === 'monorepo') {
+        return yield* init_monorepo();
+    }
+    if(config.config.action.initType === 'cargo') {
+        return yield* init_cargo();
+    }
+    if(config.config.action.initType === 'blocks') {
+        return yield* init_blocks();
+    }
+    if(config.config.action.initType === 'tauri') {
+        return yield* init_tauri();
+    }
+    if(config.config.action.initType === 'velo') {
+        return yield* init_velo();
+    }
+    if(config.config.action.initType === 'submodules') {
+        return yield* init_submodules();
+    }
+    yield* Effect.fail(new AppError({ message: `Unsupported init type: ${config.config.action.initType}`, cause: new Error(`Unsupported init type: ${config.config.action.initType}`) }));
+})

package/src/init/monorepo.ts

@@ -0,0 +1,72 @@
+import { Effect } from "effect/index"
+import { Config } from "../config.js";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { logger } from "../utils/logger.js";
+import { mergeAdditions, mergeLucySettings2PackageJson, setInitialized, setProjectName, stringReplace } from "../commands/edit.js";
+import { writeLucySettings, writePackageJson } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { readPackageJson } from "../commands/read.js";
+import { approveBuilds, installPackages, runInstall } from "../commands/install.js";
+import { cleanup } from "../commands/cleanup.js";
+import { gitInit } from "../commands/git.js";
+import { checkForDirty } from "../commands/checks.js";
+import { openVSCode } from "../commands/exec.js";
+
+export const init_monorepo = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const path = yield* Path.Path;
+        const fs = yield* FileSystem.FileSystem;
+
+        logger.action("Initializing monorepo...");
+
+        yield* checkForDirty();
+
+        const createMonoRepo = Command.make(
+            "npx", 
+            "-y",
+            "create-nx-workspace", 
+            config.config.projectName,
+            `--appName=${config.config.projectName}`,
+            `--pm=${config.config.lucySettings.packageManager}`, 
+            "--preset=ts", 
+            "--g=true",
+            "--e2eTestRunner=cypress",
+            "--formatter=prettier"
+            ).pipe(
+            Command.stdout("inherit"), // Stream stdout to process.stdout
+            Command.stderr("inherit"), // Stream stderr to process.stderr
+            Command.exitCode // Get the exit code
+        )
+
+        yield* createMonoRepo;
+        
+        const tempPath = path.join(config.config.cwd, config.config.projectName)
+        const projectFiles = yield* fs.readDirectory(tempPath)
+        yield* Effect.forEach(
+            projectFiles.filter(file => file !== '.git'),
+            (file) => fs.copy(path.join(tempPath, file), path.join(config.config.cwd, file), { overwrite: true }),
+            { discard: true }
+        )
+        yield* fs.remove(tempPath, { recursive: true })
+
+        yield* copyTemplateFiles;
+        yield* stringReplace(path.join(config.config.cwd, 'currents.config.ts'), ['__ProjectName__'], [config.config.projectName]);
+        yield* readPackageJson;
+        yield* setProjectName;
+        yield* mergeLucySettings2PackageJson;
+        yield* mergeAdditions;
+        yield* writeLucySettings;
+        yield* writePackageJson;
+        yield* gitInit();
+        yield* runInstall;
+        yield* installPackages(true);
+        yield* approveBuilds;
+        yield* cleanup;
+        yield* setInitialized;
+
+        logger.success("Monorepo initialized successfully!");
+
+        yield* openVSCode;
+    })
+}

package/src/init/prepareVelo.ts

@@ -0,0 +1,19 @@
+import { Effect } from 'effect/index';
+import { logger } from '../utils/logger.js';
+import { checkForVelo } from '../commands/checks.js';
+import { gitInit } from '../commands/git.js';
+import { installVeloPackages, runInstall } from '../commands/install.js';
+import { setInitialized } from '../commands/edit.js';
+
+export const prepareVelo = Effect.gen(function*() {
+	logger.action("Initializing Tauri project...");
+	yield* checkForVelo();
+
+	yield* gitInit(true);
+	yield* installVeloPackages
+	yield* runInstall
+	yield* setInitialized;
+	
+    logger.success("Velo Prepared initialized successfully!");
+
+})

package/src/init/tauri.ts

@@ -0,0 +1,42 @@
+import { Effect, Schema } from "effect/index"
+import { logger } from "../utils/logger.js";
+import { writeLucySettings } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { gitInit } from "../commands/git.js";
+import { checkForDirty } from "../commands/checks.js";
+import { setInitialized } from "../commands/edit.js";
+import { Config } from "../config.js";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { AppError } from "../error.js";
+import { approveBuilds, installPackages } from "../commands/install.js";
+import { openVSCode } from "../commands/exec.js";
+
+export const init_tauri = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        logger.action("Initializing Tauri project...");
+
+        yield* checkForDirty();
+
+        const initTauri = Command.make("yarn", "create", "tauri-app", config.config.projectName).pipe(
+            Command.stdin("inherit"),
+            Command.stdout("inherit"),
+            Command.stderr("inherit"),
+            Command.runInShell(true),
+            Command.exitCode
+        )
+        if((yield* initTauri) !== 0) {
+            yield* Effect.fail(new AppError({ message: "Failed to initialize Tauri project. Please check the error message above.", cause: new Error("Failed to initialize Tauri project") }));
+        }
+        yield* copyTemplateFiles;
+        yield* installPackages();
+        yield* approveBuilds;
+        yield* writeLucySettings;
+        yield* gitInit();
+        yield* setInitialized;
+
+        logger.success("Tauri project initialized successfully!");
+
+        yield* openVSCode;
+    })
+}

package/src/init/templates.ts

@@ -0,0 +1,98 @@
+import { Effect, Schema } from "effect/index";
+import { Config, lucyJsonName, lucyJsonPath } from "../config.js";
+import { orange, red, green, logger } from "../utils/logger.js";
+import { FileSystem } from "@effect/platform"
+import path, { join } from 'path';
+import fsp from 'fs/promises';
+import Enquirer from 'enquirer';
+import { AppError } from "../error.js";
+import { lucySettings } from "../schemas/lucy.js";
+import { JsonSchema } from "../schemas/index.js";
+
+export const selectTemplate = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config
+        const fs = yield* FileSystem.FileSystem;
+        const templatesPath = join(config.config.lucyHome, 'templates');
+        const files = yield* Effect.tryPromise({
+            try: () => fsp.readdir(templatesPath, { withFileTypes: true }),
+            catch: (e) => {
+                console.log((`💩 ${red.underline.bold("=> Templates folder not found at =>")} ${orange(templatesPath)}`));
+                return new AppError({ cause: e, message: 'Templates folder not found' });
+            }
+        })
+                    
+        const templateChoices: string[] = [];
+        for (const dirent of files) {
+            if (dirent.isDirectory()) {
+                const lucyRaw = yield* fs.readFileString(join(templatesPath, dirent.name, lucyJsonName));   
+                const lucySettingsJSON = yield* Schema.decodeUnknown(JsonSchema)(lucyRaw); 
+                const lucySetting = yield* Schema.decodeUnknown(lucySettings)(lucySettingsJSON)
+                if (lucySetting.type === config.config.action.initType) {
+                    templateChoices.push(dirent.name);
+                }
+            }
+        }
+
+        if (templateChoices.length === 0) {
+            console.log((`💩 ${red.underline.bold("=> No templates found in =>")} ${orange(templatesPath)}`));
+            return;
+        } 
+
+        const templateQuestion = new Enquirer();
+        const choice = yield* Effect.tryPromise({
+            try: () => templateQuestion.prompt({
+                type: 'select',
+                name: 'template',
+                message: 'Select a project template',
+                choices: templateChoices
+            }),
+            catch: (e) => {
+                return new AppError({ cause: e, message: 'Error selecting template' });
+            }
+        })
+
+    const selectedTemplate = yield* Schema.decodeUnknown(Schema.Struct({ template: Schema.String }))(choice)
+    const templateDir = join(templatesPath, selectedTemplate.template );
+    const templateFilesDir = join(templateDir, 'files');
+    config.config.templateDir = templateDir;
+    config.config.templateFiles = templateFilesDir;
+
+    const templateSettingsPath = join(templateDir, lucyJsonName);
+
+    if (!(yield* fs.exists(templateSettingsPath))) {
+        logger.warning((`💩 ${red.underline.bold(`Template is missing ${lucyJsonName} at =>`)} ${orange(templateSettingsPath)}`));
+        yield* Effect.fail(new AppError({ message: `Template is missing ${lucyJsonName}`, cause: templateSettingsPath }));
+    }
+    const lucySettingsRaw = yield* fs.readFileString(templateSettingsPath);
+    const newLucySettings = yield* Schema.decodeUnknown(lucySettings)(JSON.parse(lucySettingsRaw));
+    if( newLucySettings.type !== config.config.action.initType) return yield* Effect.fail(new AppError({
+        message: `Template type ${newLucySettings.type} does not match action type ${config.config.action.initType}`,
+        cause: newLucySettings.type
+    }));
+    if(config.config.lucySettings.initialized) {
+        const overwriteQuestion = new Enquirer();
+
+        const overwrite = yield* Effect.tryPromise({
+            try: () => overwriteQuestion.prompt({
+                type: 'confirm',
+                name: 'overwrite',
+                message: `Overwrite existing ${lucyJsonName} settings?`,
+            }),
+            catch: (e) => {
+                return new AppError({
+                    cause: e,
+                    message: "Error overwriting settings",
+                });
+            }
+        })
+        const choice = yield* Schema.decodeUnknown(Schema.Struct({ overwrite: Schema.Boolean }))(overwrite);
+        if (choice.overwrite) {
+            config.config.lucySettings = newLucySettings;
+        } else {
+            logger.info(`Existing ${lucyJsonName} settings will be used.`);
+        }
+    }
+    logger.success(`Selected template: ${green(selectedTemplate.template)}`);
+    });
+}

package/src/init/velo.ts

@@ -0,0 +1,65 @@
+import { Effect, Schema } from "effect/index"
+import { Config } from "../config.js";
+import { FileSystem, Path } from "@effect/platform"
+import { logger } from "../utils/logger.js";
+import { mergeAdditions, mergeLucySettings2PackageJson, setInitialized, setProjectName, stringReplace } from "../commands/edit.js";
+import { writeLucySettings, writePackageJson } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { readPackageJson } from "../commands/read.js";
+import { installVeloPackages, runInstall } from "../commands/install.js";
+import { cleanup } from "../commands/cleanup.js";
+import { gitInit } from "../commands/git.js";
+import { checkForVelo } from "../commands/checks.js";
+import { AppError } from "../error.js";
+import Enquirer from "enquirer";
+import { prepareVelo } from "./prepareVelo.js";
+import { openVSCode } from "../commands/exec.js";
+
+export const init_velo = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const path = yield* Path.Path;
+
+        logger.action("Initializing Velo...");
+
+        yield* checkForVelo();
+
+        if(config.config.lucySettings.initialized && !config.config.force) {
+            const question = new Enquirer();
+            const choice = yield* Effect.tryPromise({
+                try: () => question.prompt({
+                    type: 'confirm',
+                    name: 'prepare',
+                    message: 'Do you want to prepare the velo project?(install packages, git init)',
+                }),
+                catch: (e) => {
+                    return new AppError({ cause: e, message: 'Error selecting template' });
+                }
+            })
+            const prepare = yield* Schema.decodeUnknown(Schema.Struct({ prepare: Schema.Boolean }))(choice)
+            if(prepare.prepare) return yield* prepareVelo
+        }
+
+
+        if(config.config.lucySettings.initialized && !config.config.force) return yield* Effect.fail(new AppError({ message: "Lucy is already initialized in this directory. Use --force to reinitialize.", cause: new Error("Lucy is already initialized in this directory") }));
+        if ((config.config.lucySettings.initialized && config.config.force) || (config.config.lucySettings.initialized && config.config.force)) logger.alert("Forced initialization!");
+        
+        yield* copyTemplateFiles;
+        yield* stringReplace(path.join(config.config.cwd, 'currents.config.js'), ['__ProjectName__'], [config.config.projectName]);
+        yield* readPackageJson;
+        yield* setProjectName;
+        yield* mergeLucySettings2PackageJson;
+        yield* mergeAdditions;
+        yield* writeLucySettings;
+        yield* writePackageJson;
+        yield* gitInit();
+        yield* installVeloPackages;
+        yield* runInstall;
+        yield* cleanup;
+        yield* setInitialized;
+        
+        logger.success("Velo initialized successfully!");
+
+        yield* openVSCode;
+    })
+}

package/src/runtime.ts

@@ -18,3 +18,4 @@ export const build_runtime = (args: Awaited<ReturnType<typeof get_args>>) => {
         }))
     ))
 };
+

package/src/schemas/gulp.ts

@@ -0,0 +1,31 @@
+import { LucySettings } from "./lucy";
+import * as dartSass from 'sass';
+import gulpSass from 'gulp-sass';
+import backendSettings from '../../settings/backend-settings.json' with { type: "json" };;
+import masterSettings from '../../settings/master-settings.json' with { type: "json" };;
+import pageSettings from '../../settings/page-settings.json' with { type: "json" };;
+import publicSettings from '../../settings/public-settings.json' with { type: "json" };;
+
+const sass = gulpSass(dartSass);
+
+export type TaskOptions = {
+    enableIncrementalBuild: boolean;
+    outputDir: string;
+    sass: ReturnType<typeof gulpSass>;
+    replaceOptions: {
+        logs: {
+            enabled: boolean;
+        }
+    };
+    backendSettings: typeof backendSettings,
+    masterSettings: typeof masterSettings,
+    pageSettings: typeof pageSettings,
+    publicSettings: typeof publicSettings,
+    modulesSourcePaths: string[];
+    cwd: string;
+}
+
+export interface File {
+	path: string;
+	dirname: string;
+}

package/src/schemas/index.ts

@@ -1,3 +1,15 @@
 import { Schema } from "effect/index";
 
-export const JsonSchema = Schema.parseJson()
+export const JsonSchema = Schema.parseJson()
+
+export const veloSyncSettings = Schema.Struct({
+	siteUrl: Schema.String,
+	secret: Schema.String,
+});
+export type VeloSyncSettings = typeof veloSyncSettings.Type;
+
+export const wixSDKSettings = Schema.Struct({
+	apiKey: Schema.String,
+	siteId: Schema.String,
+});
+export type WixSDKSettings = typeof wixSDKSettings.Type;

package/src/schemas/lucy.ts

@@ -0,0 +1,43 @@
+import { Schema } from "effect/index";
+import { initTypes } from "./types.js";
+
+export const pkgManagers = ['pnpm', 'npm', 'yarn'] as const;
+export const lucySettings = Schema.mutable(Schema.Struct({
+	modules: Schema.Record({
+        key: Schema.String, 
+        value: Schema.Struct({
+		source: Schema.String,
+		branch: Schema.String,
+		path: Schema.optional(Schema.String),
+		noCompile: Schema.optional(Schema.Boolean),
+	})}),
+	veloSettings: Schema.optional(Schema.NullOr(Schema.Struct({
+		compilerOptions: Schema.optional(Schema.Struct({
+			composite: Schema.Boolean,
+			noEmit: Schema.Boolean,
+			lib: Schema.Array(Schema.String),
+			jsx: Schema.String,
+		})),
+		exclude: Schema.optional(Schema.Array(Schema.String)),
+	}))),
+	initialized: Schema.Boolean,
+    type: Schema.Literal(...initTypes),
+	dependencies: Schema.mutable(Schema.Record({
+        key: Schema.String,
+        value: Schema.String,
+    })),
+	devDependencies: Schema.mutable(Schema.Record({
+        key: Schema.String,
+        value: Schema.String,
+    })),
+	scripts: Schema.Record({
+        key: Schema.String,
+        value: Schema.String,
+    }),
+	additionalCommands: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
+	additionalPkgProps: Schema.optional(Schema.Object),
+	packageManager: Schema.mutable(Schema.Literal(...pkgManagers)),
+	defaultModulePath: Schema.optional(Schema.String),
+}));
+
+export type LucySettings = typeof lucySettings.Type;

package/src/schemas/types.ts

@@ -0,0 +1,40 @@
+export const initTypes = ["velo", "expo", "blocks", "monorepo", "tauri", "cargo", 'submodules', 'wix-sdk'] as const;
+export const taskNames = ["dev", "build", "build-prod", "build-pipeline", "sync-settings"] as const;
+export const syncActions = ["sync", "import", "init", "is-alive", "migrate", "export"] as const;
+export const WixSDKActions = ["init", ""] as const;
+export type Action = 'init' | 'open' | 'task' | 'wix-sync';
+import gulp from 'gulp';
+
+export type SyncTaskType = (filename: string, collection: string, schemaFilename: string, importOnly: boolean, dryrun: boolean) => Promise<void>;
+export type MigrateFileCache = () => Promise<void>;
+export type TaskType = ReturnType< typeof gulp.parallel>
+
+export type Actions = {
+    action: Action;
+    initType?: typeof initTypes[number];
+    tasksName?: typeof taskNames[number];
+    syncAction?: typeof syncActions[number];
+    wixSDKAction?: typeof WixSDKActions[number];
+}
+
+export interface LucyArgs {
+    [x: string]: unknown;
+    // This will hold the command used, e.g., 'init'
+    _: Action[];
+    $0: string;
+    // Arguments for the 'init' command
+    initType?: Actions['initType'];
+    tasksName?: Actions['tasksName'];
+    syncAction?: Actions['syncAction'];
+    wixSDKAction?: Actions['wixSDKAction'];
+    // wix-sync options
+    input?: string;        // Alias for -f
+    collection?: string;  // Alias for -c
+    schema?: string;      // Alias for -s
+    d?: boolean;    
+}
+
+export interface VeloSyncConfig {
+    siteUrl: string;
+    secret: string;
+}