lucy-cli 2.0.0-alpha.11 → 2.0.0-alpha.12

package/src/index.ts

@@ -5,32 +5,68 @@ import { get_args } from "./args.js";
 import 'dotenv/config'
 import { Config } from "./config.js";
 import { ServiceInspectState } from "./states.js";
-import { init } from "./init.js";
-
+import { init } from "./init/index.js";
+import { logger } from "./utils/logger.js";
+import { AppError } from "./error.js";
+import { open } from "./commands/exec.js";
+import { runTask } from "./tasks/Gulpfile.js";
+import { tasks } from "./tasks/index.js";
 
 const lucyCLI = pipe(
     Effect.gen(function* (_) {
         const config = yield* Config; 
+        const t = Config; 
         config.config.action.type;
-        if (config.config.action.type === undefined) {
-            return yield* Effect.fail("No Params Provided");
-        }
         if (config.config.action.action === 'init') {
             return yield* init();
         }
-
+        if (config.config.action.action === 'open') {
+            return yield* open;
+        }
+        if (config.config.action.action === 'task') {
+            return yield* tasks();
+        }
 
     }),
+).pipe(
+    Effect.catchTags({
+        BadArgument: (error) => {
+            logger.error(JSON.stringify(error, null, 2));
+            return Effect.fail(new Error(error.message));
+        },
+        ParseError: (error) => {
+            logger.error("Failed to parse:", JSON.stringify(error, null, 2));
+            return Effect.fail(new Error("Failed to parse: " + error.message));
+        },
+        SystemError: (error) => {
+            logger.error("System error:", JSON.stringify(error, null, 2));
+            return Effect.fail(new Error("System error: " + error.message));
+        },   
+        AppError: (error) => {
+            logger.error("Application error:", JSON.stringify(error, null, 2));
+            return Effect.fail(new Error("Application error: " + error.message));
+        }
+    })
 )
 
 async function main() {
     const args = await get_args();
     const runtime= build_runtime(args);
     // The runtime will handle logging failures. This will catch unhandled defects.
-    await runtime.runPromise(lucyCLI)
+    const program = Effect.orDieWith(
+        lucyCLI,
+        (error) => new Error(`The application failed to run: ${error}`
+        )
+)
+    await runtime.runPromise(program)
 }
 
-main().catch((error) => {
-    console.error("An unexpected application error occurred:", error);
+main().then(() => {
+    process.exit(0);
+}).catch((error) => {
+    if (error instanceof Error) {
+        logger.error(error.message);
+        console.debug(JSON.stringify(error, null, 2));
+    }
     process.exit(1);
 });

package/src/init/blocks.ts

@@ -0,0 +1,82 @@
+import { Effect, Schema } from "effect/index"
+import { Config } from "../config.js";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { JsonSchema } from "../schemas/index.js";
+import { logger } from "../utils/logger.js";
+import { mergeAdditions, mergeLucySettings2PackageJson, setInitialized } from "../commands/edit.js";
+import { writeLucySettings, writePackageJson } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { readPackageJson } from "../commands/read.js";
+import { execCommand } from "../commands/exec.js";
+import { installPackages } from "../commands/install.js";
+import { AppError } from "../error.js";
+import { cleanup } from "../commands/cleanup.js";
+import { checkForDirty } from "../commands/checks.js";
+
+export const init_blocks = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+
+        logger.action("Initializing Blocks project...");
+
+        const configJsonRaw = yield* fs.readFile("wix.config.json").pipe(Effect.catchAll((error) => {
+            return Effect.succeed('{}');
+        }))
+        const configJson = Schema.decodeUnknownSync(JsonSchema)(configJsonRaw.toString()) as any;
+        const blocksAppReady = configJson.appId ? true : false;
+
+        yield* checkForDirty();
+
+        if(!blocksAppReady) {
+            const initBlocks = Command.make("npm", "create", "@wix/app@latest", config.config.projectName).pipe(
+                Command.stdin("inherit"),
+                Command.stdout("inherit"),
+                Command.stderr("inherit"),
+                Command.exitCode
+            )
+            if((yield* initBlocks) !== 0) {
+                yield* Effect.fail(new AppError({ message: "Failed to initialize Blocks project. Please check the error message above.", cause: new Error("Failed to initialize Blocks project") }));
+            }
+            const files = yield * fs.readDirectory(config.config.cwd, { recursive: false });
+
+            const allExcludes = ['.git', 'lucy.json'];
+            const filteredFiles = files.filter(file => !allExcludes.includes(file));
+
+            const t = yield* fs.stat(filteredFiles[0]);
+            t.type === 'Directory'
+
+            const directories = yield* Effect.filter(
+                filteredFiles,
+                (file) => Effect.gen(function*() {
+                    const fullPath = path.join(config.config.cwd, file);
+                    const stat = yield* fs.stat(fullPath);
+                    return stat.type === "Directory";
+                })
+            );
+            const tempPath = directories[0];
+
+            const projectFiles = yield* fs.readDirectory(directories[0])
+            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* readPackageJson;
+        yield* mergeLucySettings2PackageJson;
+        yield* mergeAdditions;
+        yield* writeLucySettings;
+        yield* writePackageJson;
+        yield* copyTemplateFiles;
+        yield* execCommand;
+        yield* installPackages;
+        yield* cleanup;
+        yield* setInitialized;
+
+        logger.success("Blocks project initialized successfully!");
+    })
+}

package/src/init/cargo.ts

@@ -0,0 +1,22 @@
+import { Effect } 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";
+
+export const init_cargo = () => {
+    return Effect.gen(function*() {
+        logger.action("Initializing Cargo project...");
+
+        yield* checkForDirty();
+
+        yield* copyTemplateFiles;
+        yield* writeLucySettings;
+        yield* gitInit();
+        yield* setInitialized;
+        
+        logger.success("Cargo project initialized successfully!");
+    })
+}

package/src/init/expo.ts

@@ -0,0 +1,66 @@
+import { Effect, Schema } from "effect/index"
+import { Config } from "../config.js";
+import { Command, FileSystem, Path } from "@effect/platform"
+import { JsonSchema } from "../schemas/index.js";
+import { logger } from "../utils/logger.js";
+import { mergeAdditions, mergeLucySettings2PackageJson, setInitialized } from "../commands/edit.js";
+import { writeLucySettings, writePackageJson } from "../commands/write.js";
+import { copyTemplateFiles } from "../commands/copy.js";
+import { readPackageJson } from "../commands/read.js";
+import { execCommand } from "../commands/exec.js";
+import { installPackages } from "../commands/install.js";
+import { AppError } from "../error.js";
+import { cleanup } from "../commands/cleanup.js";
+import { checkForDirty } from "../commands/checks.js";
+
+export const init_expo = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const fs = yield* FileSystem.FileSystem;
+        const path = yield* Path.Path;
+
+        logger.action("Initializing Expo project...");
+
+        const appJsonRaw = yield* fs.readFile("app.json").pipe(Effect.catchAll((error) => {
+            return Effect.succeed('{}');
+        }))
+        const appJSON = Schema.decodeUnknownSync(JsonSchema)(appJsonRaw.toString()) as any;
+        const expoAppReady = appJSON.expo ? true : false;
+
+        yield* checkForDirty();
+
+        if(!expoAppReady) {
+            const initExpo = Command.make("npx", "create-expo-app@latest", config.config.projectName, "--template", "blank-typescript", "--no-install").pipe(
+                Command.stdout("inherit"),
+                Command.exitCode
+            )
+            if((yield* initExpo) !== 0) {
+                yield* Effect.fail(new AppError({ message: "Failed to initialize Expo project. Please check the error message above.", cause: new Error("Failed to initialize Expo project") }));
+            }
+
+            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* readPackageJson;
+        yield* mergeLucySettings2PackageJson;
+        yield* mergeAdditions;
+        yield* writeLucySettings;
+        yield* writePackageJson;
+        yield* copyTemplateFiles;
+        yield* execCommand;
+        yield* installPackages;
+        yield* cleanup;
+        yield* setInitialized;
+        
+        logger.success("Expo project initialized successfully!");
+
+    })
+}

package/src/init/gitModules.ts

@@ -0,0 +1,15 @@
+import { Effect } from "effect/index"
+import { logger } from "../utils/logger.js";
+import { setInitialized } from "../commands/edit.js";
+import { gitInit } from "../commands/git.js";
+
+export const init_submodules = () => {
+    return Effect.gen(function*() {
+        logger.action("Initializing Git submodules project...");
+
+        yield* gitInit(true);
+        yield* setInitialized;
+        
+        logger.success("GIT initialized successfully!");
+    })
+}

package/src/init/index.ts

@@ -0,0 +1,69 @@
+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";
+
+
+export const init = () => {
+    return Effect.gen(function* (_) {
+        const config = yield* Config;
+        if(config.config.action.type === undefined) {
+            return yield* Effect.fail(new AppError({ message: "No action type provided", cause: new Error("No action 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;
+
+        if(config.config.action.type === 'expo') {
+            return yield* init_expo();
+        }
+        if(config.config.action.type === 'monorepo') {
+            return yield* init_monorepo();
+        }
+        if(config.config.action.type === 'cargo') {
+            return yield* init_cargo();
+        }
+        if(config.config.action.type === 'blocks') {
+            return yield* init_blocks();
+        }
+        if(config.config.action.type === 'tauri') {
+            return yield* init_tauri();
+        }
+        if(config.config.action.type === 'velo') {
+            return yield* init_velo();
+        }
+        if(config.config.action.type === 'submodules') {
+            return yield* init_submodules();
+        }
+
+        yield* Effect.fail(new AppError({ message: `Unsupported action type: ${config.config.action.type}`, cause: new Error(`Unsupported action type: ${config.config.action.type}`) }));
+    })
+}

package/src/init/monorepo.ts

@@ -0,0 +1,39 @@
+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 { runYarn, yarnSetVersion } from "../commands/install.js";
+import { cleanup } from "../commands/cleanup.js";
+import { gitInit } from "../commands/git.js";
+import { checkForDirty } from "../commands/checks.js";
+
+export const init_monorepo = () => {
+    return Effect.gen(function*() {
+        const config = yield* Config;
+        const path = yield* Path.Path;
+
+        logger.action("Initializing monorepo...");
+
+        yield* checkForDirty();
+
+        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* yarnSetVersion;
+        yield* runYarn;
+        yield* cleanup;
+        yield* setInitialized;
+        
+        logger.success("Monorepo initialized successfully!");
+    })
+}

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, yarnSetVersion } 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* yarnSetVersion;
+	yield* installVeloPackages
+	yield* setInitialized;
+	
+    logger.success("Velo Prepared initialized successfully!");
+
+})

package/src/init/tauri.ts

@@ -0,0 +1,40 @@
+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 { JsonSchema } from "../schemas/index.js";
+import { AppError } from "../error.js";
+import { installPackages } from "../commands/install.js";
+import { Terminal } from "@effect/platform"
+
+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* writeLucySettings;
+        yield* gitInit();
+        yield* setInitialized;
+
+        logger.success("Tauri project initialized successfully!");
+    })
+}

package/src/init/templates.ts

@@ -0,0 +1,99 @@
+import { Effect, Schema } from "effect/index";
+import { Config } 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 lucyJsonPath = join(templatesPath, dirent.name, 'lucy.json');
+                const lucyRaw = yield* fs.readFileString(lucyJsonPath, 'utf-8');   
+                const lucySettingsJSON = yield* Schema.decodeUnknown(JsonSchema)(lucyRaw); 
+                const lucySetting = yield* Schema.decodeUnknown(lucySettings)(lucySettingsJSON)
+                if (lucySetting.type === config.config.action.type) {
+                    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, 'lucy.json');
+
+    if (!(yield* fs.exists(templateSettingsPath))) {
+        logger.warning((`💩 ${red.underline.bold("=> Template is missing lucy.json at =>")} ${orange(templateSettingsPath)}`));
+        yield* Effect.fail(new AppError({ message: 'Template is missing lucy.json', cause: templateSettingsPath }));
+    }
+    const lucySettingsRaw = yield* fs.readFileString(templateSettingsPath, 'utf-8');
+    const newLucySettings = yield* Schema.decodeUnknown(lucySettings)(JSON.parse(lucySettingsRaw));
+    if( newLucySettings.type !== config.config.action.type) return yield* Effect.fail(new AppError({
+        message: `Template type ${newLucySettings.type} does not match action type ${config.config.action.type}`,
+        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 lucy.json 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 lucy.json settings will be used.`);
+        }
+    }
+    logger.success(`Selected template: ${green(selectedTemplate.template)}`);
+    });
+}

package/src/init/velo.ts

@@ -0,0 +1,62 @@
+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, runYarn, yarnSetVersion } 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";
+
+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* yarnSetVersion;
+        yield* installVeloPackages;
+        yield* cleanup;
+        yield* setInitialized;
+        
+        logger.success("Velo initialized successfully!");
+    })
+}

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,23 @@
+import { LucySettings } from "./lucy";
+import * as dartSass from 'sass';
+import gulpSass from 'gulp-sass';
+
+const sass = gulpSass(dartSass);
+
+export type ModuleSettings = {
+    packageRoot: string;
+    targetFolder: string;
+    wixConfigPath: string;
+    lucyConfigPath: string;
+    packageJsonPath: string;
+    settings: LucySettings;
+    force: boolean;
+    veloConfigName: string;
+}
+
+export type ProjectSettings = {
+    // packages?: Record<string, string>;
+    modules?: Record<string, any>;
+    lucySettings?: LucySettings;
+    packageJSON?: Record<string, any>;
+}

package/src/schemas/lucy.ts

@@ -0,0 +1,39 @@
+import { Schema } from "effect/index";
+import { types } from "./types.js";
+
+export const lucySettings = 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(...types),
+	dependencies: Schema.Record({
+        key: Schema.String,
+        value: Schema.String,
+    }),
+	devDependencies: 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),
+});
+export type LucySettings = typeof lucySettings.Type;