@nexical/cli 0.10.0 → 0.11.1

package/src/commands/module/remove.ts

@@ -4,71 +4,76 @@ import path from 'path';
 import YAML from 'yaml';
 
 export default class ModuleRemoveCommand extends BaseCommand {
-    static usage = 'module remove <name>';
-    static description = 'Remove an installed module.';
-    static requiresProject = true;
+  static usage = 'module remove <name>';
+  static description = 'Remove an installed module.';
+  static requiresProject = true;
 
-    static args: CommandDefinition = {
-        args: [
-            { name: 'name', required: true, description: 'Name of the module to remove' }
-        ]
-    };
+  static args: CommandDefinition = {
+    args: [{ name: 'name', required: true, description: 'Name of the module to remove' }],
+  };
 
-    async run(options: any) {
-        const projectRoot = this.projectRoot as string;
-        let { name } = options;
+  async run(options: { name: string }) {
+    const projectRoot = this.projectRoot as string;
+    const { name } = options;
 
-        const relativePath = `modules/${name}`;
-        const fullPath = path.resolve(projectRoot, relativePath);
+    const relativePath = `modules/${name}`;
+    const fullPath = path.resolve(projectRoot, relativePath);
 
-        logger.debug('Removing module at:', fullPath);
+    logger.debug('Removing module at:', fullPath);
 
-        if (!(await fs.pathExists(fullPath))) {
-            this.error(`Module ${name} not found at ${relativePath}.`);
-            return;
-        }
-
-        this.info(`Removing module ${name}...`);
+    if (!(await fs.pathExists(fullPath))) {
+      this.error(`Module ${name} not found at ${relativePath}.`);
+      return;
+    }
 
-        try {
-            await runCommand(`git submodule deinit -f ${relativePath}`, projectRoot);
-            await runCommand(`git rm -f ${relativePath}`, projectRoot);
+    this.info(`Removing module ${name}...`);
 
-            // Clean up .git/modules
-            const gitModulesDir = path.resolve(projectRoot, '.git', 'modules', 'modules', name);
-            if (await fs.pathExists(gitModulesDir)) {
-                await fs.remove(gitModulesDir);
-            }
+    try {
+      await runCommand(`git submodule deinit -f ${relativePath}`, projectRoot);
+      await runCommand(`git rm -f ${relativePath}`, projectRoot);
 
-            this.info('Syncing workspace dependencies...');
-            await runCommand('npm install', projectRoot);
+      // Clean up .git/modules
+      const gitModulesDir = path.resolve(projectRoot, '.git', 'modules', 'modules', name);
+      if (await fs.pathExists(gitModulesDir)) {
+        await fs.remove(gitModulesDir);
+      }
 
+      this.info('Syncing workspace dependencies...');
+      await runCommand('npm install', projectRoot);
 
-            await this.removeFromConfig(name);
+      await this.removeFromConfig(name);
 
-            this.success(`Module ${name} removed successfully.`);
-        } catch (e: any) {
-            this.error(`Failed to remove module: ${e.message}`);
-        }
+      this.success(`Module ${name} removed successfully.`);
+    } catch (e: unknown) {
+      if (e instanceof Error) {
+        this.error(`Failed to remove module: ${e.message}`);
+      } else {
+        this.error(`Failed to remove module: ${String(e)}`);
+      }
     }
-
-    private async removeFromConfig(moduleName: string) {
-        const projectRoot = this.projectRoot as string;
-        const configPath = path.join(projectRoot, 'nexical.yaml');
-
-        if (!await fs.pathExists(configPath)) return;
-
-        try {
-            const content = await fs.readFile(configPath, 'utf8');
-            let config = YAML.parse(content) || {};
-
-            if (config.modules && config.modules.includes(moduleName)) {
-                config.modules = config.modules.filter((m: string) => m !== moduleName);
-                await fs.writeFile(configPath, YAML.stringify(config));
-                logger.debug(`Removed ${moduleName} from nexical.yaml modules list.`);
-            }
-        } catch (e: any) {
-            logger.warn(`Failed to update nexical.yaml: ${e.message}`);
-        }
+  }
+
+  private async removeFromConfig(moduleName: string) {
+    const projectRoot = this.projectRoot as string;
+    const configPath = path.join(projectRoot, 'nexical.yaml');
+
+    if (!(await fs.pathExists(configPath))) return;
+
+    try {
+      const content = await fs.readFile(configPath, 'utf8');
+      const config = YAML.parse(content) || {};
+
+      if (config.modules && config.modules.includes(moduleName)) {
+        config.modules = config.modules.filter((m: string) => m !== moduleName);
+        await fs.writeFile(configPath, YAML.stringify(config));
+        logger.debug(`Removed ${moduleName} from nexical.yaml modules list.`);
+      }
+    } catch (e: unknown) {
+      if (e instanceof Error) {
+        logger.warn(`Failed to update nexical.yaml: ${e.message}`);
+      } else {
+        logger.warn(`Failed to update nexical.yaml: ${String(e)}`);
+      }
     }
+  }
 }

package/src/commands/module/update.ts

@@ -3,48 +3,50 @@ import fs from 'fs-extra';
 import path from 'path';
 
 export default class ModuleUpdateCommand extends BaseCommand {
-    static usage = 'module update [name]';
-    static description = 'Update a specific module or all modules.';
-    static requiresProject = true;
-
-    static args: CommandDefinition = {
-        args: [
-            { name: 'name', required: false, description: 'Name of the module to update' }
-        ]
-    };
-
-    async run(options: any) {
-        const projectRoot = this.projectRoot as string;
-        let { name } = options;
-
-        this.info(name ? `Updating module ${name}...` : 'Updating all modules...');
-        logger.debug('Update context:', { name, projectRoot: projectRoot });
-
-        try {
-            if (name) {
-                const relativePath = `modules/${name}`;
-                const fullPath = path.resolve(projectRoot, relativePath);
-
-                if (!(await fs.pathExists(fullPath))) {
-                    this.error(`Module ${name} not found.`);
-                    return;
-                }
-
-                // Update specific module
-                // We enter the directory and pull? Or generic submodule update?
-                // Generic submodule update --remote src/modules/name
-                await runCommand(`git submodule update --remote --merge ${relativePath}`, projectRoot);
-            } else {
-                // Update all
-                await runCommand('git submodule update --remote --merge', projectRoot);
-            }
-
-            this.info('Syncing workspace dependencies...');
-            await runCommand('npm install', projectRoot);
-
-            this.success('Modules updated successfully.');
-        } catch (e: any) {
-            this.error(`Failed to update modules: ${e.message}`);
+  static usage = 'module update [name]';
+  static description = 'Update a specific module or all modules.';
+  static requiresProject = true;
+
+  static args: CommandDefinition = {
+    args: [{ name: 'name', required: false, description: 'Name of the module to update' }],
+  };
+
+  async run(options: { name?: string }) {
+    const projectRoot = this.projectRoot as string;
+    const { name } = options;
+
+    this.info(name ? `Updating module ${name}...` : 'Updating all modules...');
+    logger.debug('Update context:', { name, projectRoot: projectRoot });
+
+    try {
+      if (name) {
+        const relativePath = `modules/${name}`;
+        const fullPath = path.resolve(projectRoot, relativePath);
+
+        if (!(await fs.pathExists(fullPath))) {
+          this.error(`Module ${name} not found.`);
+          return;
         }
+
+        // Update specific module
+        // We enter the directory and pull? Or generic submodule update?
+        // Generic submodule update --remote src/modules/name
+        await runCommand(`git submodule update --remote --merge ${relativePath}`, projectRoot);
+      } else {
+        // Update all
+        await runCommand('git submodule update --remote --merge', projectRoot);
+      }
+
+      this.info('Syncing workspace dependencies...');
+      await runCommand('npm install', projectRoot);
+
+      this.success('Modules updated successfully.');
+    } catch (e: unknown) {
+      if (e instanceof Error) {
+        this.error(`Failed to update modules: ${e.message}`);
+      } else {
+        this.error(`Failed to update modules: ${String(e)}`);
+      }
     }
+  }
 }

package/src/commands/run.ts

@@ -5,94 +5,102 @@ import { spawn } from 'child_process';
 import process from 'node:process';
 
 export default class RunCommand extends BaseCommand {
-    static usage = 'run <script> [args...]';
-    static description = 'Run a script inside the Nexical environment.';
-    static requiresProject = true;
-
-    static args: CommandDefinition = {
-        args: [
-            { name: 'script', required: true, description: 'The script to run (script-name OR module:script-name)' },
-            { name: 'args...', required: false, description: 'Arguments for the script' }
-        ]
-    };
+  static usage = 'run <script> [args...]';
+  static description = 'Run a script inside the Nexical environment.';
+  static requiresProject = true;
+
+  static args: CommandDefinition = {
+    args: [
+      {
+        name: 'script',
+        required: true,
+        description: 'The script to run (script-name OR module:script-name)',
+      },
+      { name: 'args...', required: false, description: 'Arguments for the script' },
+    ],
+  };
+
+  async run(options: { script: string; args?: string[] }) {
+    const projectRoot = this.projectRoot as string;
+    const script = options.script;
+    const scriptArgs = options.args || [];
+
+    if (!script) {
+      this.error('Please specify a script to run.');
+      return;
+    }
 
-    async run(options: any) {
-        const projectRoot = this.projectRoot as string;
-        const script = options.script;
-        const scriptArgs = options.args || [];
+    logger.debug('Run command context:', { script, args: scriptArgs, projectRoot });
 
-        if (!script) {
-            this.error('Please specify a script to run.');
-            return;
-        }
+    let execPath = projectRoot;
+    let scriptName = script;
 
-        logger.debug('Run command context:', { script, args: scriptArgs, projectRoot });
+    // Handle module:script syntax
+    if (script.includes(':')) {
+      const [moduleName, name] = script.split(':');
+      execPath = path.resolve(projectRoot, 'modules', moduleName);
+      scriptName = name;
 
-        let execPath = projectRoot;
-        let scriptName = script;
+      logger.debug(`Resolving module script: ${moduleName}:${scriptName} at ${execPath}`);
+    } else {
+      logger.debug(`Resolving core script: ${scriptName} at ${execPath}`);
+    }
 
-        // Handle module:script syntax
-        if (script.includes(':')) {
-            const [moduleName, name] = script.split(':');
-            execPath = path.resolve(projectRoot, 'modules', moduleName);
-            scriptName = name;
+    // Validate script existence
+    const pkgJsonPath = path.join(execPath, 'package.json');
+    if (!(await fs.pathExists(pkgJsonPath))) {
+      this.error(`Failed to find package.json at ${execPath}`);
+      return;
+    }
 
-            logger.debug(`Resolving module script: ${moduleName}:${scriptName} at ${execPath}`);
-        } else {
-            logger.debug(`Resolving core script: ${scriptName} at ${execPath}`);
-        }
+    try {
+      const pkg = await fs.readJson(pkgJsonPath);
+      if (!pkg.scripts || !pkg.scripts[scriptName]) {
+        const type = script.includes(':') ? `module ${script.split(':')[0]}` : 'Nexical core';
+        this.error(`Script "${scriptName}" does not exist in ${type}`);
+        return;
+      }
+    } catch (e: unknown) {
+      if (e instanceof Error) {
+        this.error(`Failed to read package.json at ${execPath}: ${e.message}`);
+      } else {
+        this.error(`Failed to read package.json at ${execPath}: ${String(e)}`);
+      }
+      return;
+    }
 
-        // Validate script existence
-        const pkgJsonPath = path.join(execPath, 'package.json');
-        if (!(await fs.pathExists(pkgJsonPath))) {
-            this.error(`Failed to find package.json at ${execPath}`);
-            return;
-        }
+    const finalArgs = ['run', scriptName, '--', ...scriptArgs];
+    logger.debug(`Executing: npm ${finalArgs.join(' ')} in ${execPath}`);
+
+    const child = spawn('npm', finalArgs, {
+      cwd: execPath,
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        FORCE_COLOR: '1',
+      },
+    });
+
+    // Handle process termination to kill child
+    const cleanup = () => {
+      child.kill();
+      process.exit();
+    };
 
-        try {
-            const pkg = await fs.readJson(pkgJsonPath);
-            if (!pkg.scripts || !pkg.scripts[scriptName]) {
-                const type = script.includes(':') ? `module ${script.split(':')[0]}` : 'Nexical core';
-                this.error(`Script "${scriptName}" does not exist in ${type}`);
-                return;
-            }
-        } catch (e: any) {
-            this.error(`Failed to read package.json at ${execPath}: ${e.message}`);
-            return;
-        }
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
 
-        const finalArgs = ['run', scriptName, '--', ...scriptArgs];
-        logger.debug(`Executing: npm ${finalArgs.join(' ')} in ${execPath}`);
-
-        const child = spawn('npm', finalArgs, {
-            cwd: execPath,
-            stdio: 'inherit',
-            env: {
-                ...process.env,
-                FORCE_COLOR: '1'
-            }
-        });
-
-        // Handle process termination to kill child
-        const cleanup = () => {
-            child.kill();
-            process.exit();
-        };
-
-        process.on('SIGINT', cleanup);
-        process.on('SIGTERM', cleanup);
-
-        await new Promise<void>((resolve) => {
-            child.on('close', (code) => {
-                // Remove listeners to prevent memory leaks if this command is run multiple times in-process (e.g. tests)
-                process.off('SIGINT', cleanup);
-                process.off('SIGTERM', cleanup);
-
-                if (code !== 0) {
-                    process.exit(code || 1);
-                }
-                resolve();
-            });
-        });
-    }
+    await new Promise<void>((resolve) => {
+      child.on('close', (code) => {
+        // Remove listeners to prevent memory leaks if this command is run multiple times in-process (e.g. tests)
+        process.off('SIGINT', cleanup);
+        process.off('SIGTERM', cleanup);
+
+        if (code !== 0) {
+          process.exit(code || 1);
+        }
+        resolve();
+      });
+    });
+  }
 }

package/src/commands/setup.ts

@@ -0,0 +1,92 @@
+import { BaseCommand, logger } from '@nexical/cli-core';
+import fs from 'fs-extra';
+import path from 'path';
+
+export default class SetupCommand extends BaseCommand {
+  static description = 'Setup the application environment by symlinking core assets.';
+
+  async run() {
+    // We assume we are in the project root
+    // But the CLI might be run from anywhere?
+    // findProjectRoot in index.ts handles finding the root.
+    // BaseCommand has this.projectRoot?
+
+    // BaseCommand doesn't expose projectRoot directly in current implementation seen in memory, checking source if possible?
+    // InitCommand used process.cwd().
+
+    // Let's assume process.cwd() is project root if run via `npm run setup` from root.
+    const rootDir = process.cwd();
+
+    // Verify we are in the right place
+    if (!fs.existsSync(path.join(rootDir, 'core'))) {
+      this.error('Could not find "core" directory. Are you in the project root?');
+      process.exit(1);
+    }
+
+    const apps = ['frontend', 'backend'];
+    const sharedAssets = [
+      'prisma',
+      'src',
+      'public',
+      'locales',
+      'scripts',
+      'astro.config.mjs',
+      'tsconfig.json',
+    ]; // tsconfig might be needed if extended
+
+    for (const app of apps) {
+      const appDir = path.join(rootDir, 'apps', app);
+      if (!fs.existsSync(appDir)) {
+        this.warn(`App directory ${app} not found. Skipping.`);
+        continue;
+      }
+
+      this.info(`Setting up ${app}...`);
+
+      for (const asset of sharedAssets) {
+        const source = path.join(rootDir, 'core', asset);
+        const dest = path.join(appDir, asset);
+
+        if (!fs.existsSync(source)) {
+          this.warn(`Source asset ${asset} not found in core.`);
+          continue;
+        }
+
+        try {
+          // Remove existing destination if it exists (to ensure clean symlink)
+          // Be careful not to delete real files if they aren't symlinks?
+          // For now, we assume setup controls these.
+
+          const destDir = path.dirname(dest);
+          await fs.ensureDir(destDir);
+
+          try {
+            fs.lstatSync(dest);
+            fs.removeSync(dest);
+          } catch (e: unknown) {
+            if (
+              e &&
+              typeof e === 'object' &&
+              'code' in e &&
+              (e as { code: string }).code !== 'ENOENT'
+            )
+              throw e;
+          }
+
+          const relSource = path.relative(destDir, source);
+          await fs.symlink(relSource, dest);
+
+          logger.debug(`Symlinked ${asset} to ${app}`);
+        } catch (e: unknown) {
+          if (e instanceof Error) {
+            this.error(`Failed to symlink ${asset} to ${app}: ${e.message}`);
+          } else {
+            this.error(`Failed to symlink ${asset} to ${app}: ${String(e)}`);
+          }
+        }
+      }
+    }
+
+    this.success('Application setup complete.');
+  }
+}