@nexical/cli 0.11.0 → 0.11.1

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

@@ -3,72 +3,90 @@ 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.';
+  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?
+  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().
+    // 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();
+    // 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);
-        }
+    // 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 {
-                        const stats = fs.lstatSync(dest);
-                        fs.removeSync(dest);
-                    } catch (e: any) {
-                        if (e.code !== 'ENOENT') throw e;
-                    }
-
-                    const relSource = path.relative(destDir, source);
-                    await fs.symlink(relSource, dest);
-
-                    logger.debug(`Symlinked ${asset} to ${app}`);
-                } catch (e: any) {
-                    this.error(`Failed to symlink ${asset} to ${app}: ${e.message}`);
-                }
-            }
+    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;
         }
 
-        this.success('Application setup complete.');
+        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.');
+  }
 }