@nexical/cli 0.11.0 → 0.11.2

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,82 @@ 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']; // 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;
+      }
 
-        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}`);
-                }
-            }
+      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.');
+  }
 }

package/src/utils/discovery.ts

@@ -4,131 +4,116 @@ import fs from 'node:fs';
 
 /**
  * Discovers command directories to load into the CLI.
- * 
+ *
  * Scans for:
  * 1. Core commands (projectRoot/src/commands)
  * 2. Module commands (projectRoot/src/modules/ * /src/commands)
- * 
+ *
  * @param projectRoot - The root directory of the project
  * @returns Array of absolute paths to command directories
  */
 export function discoverCommandDirectories(projectRoot: string): string[] {
-    const directories: string[] = [];
-    const visited = new Set<string>();
-
-    const addDir = (dir: string) => {
-        const resolved = path.resolve(dir);
-        if (visited.has(resolved)) return;
-
-        if (fs.existsSync(resolved)) {
-            // Check if we already have a similar path (e.g. dist/src/commands vs src/commands)
-            // If we are adding src/commands and dist/src/commands already exists in visited, skip it
-            // and vice versa.
-            const isSrc = resolved.endsWith(path.join('src', 'commands'));
-            const isDist = resolved.includes(path.join('dist', 'src', 'commands')) ||
-                resolved.endsWith(path.join('dist', 'commands'));
-
-            if (isSrc) {
-                const distEquivalent1 = resolved.replace(path.sep + 'src' + path.sep, path.sep + 'dist' + path.sep + 'src' + path.sep);
-                const distEquivalent2 = resolved.replace(path.sep + 'src' + path.sep, path.sep + 'dist' + path.sep);
-                if (visited.has(distEquivalent1) || visited.has(distEquivalent2)) {
-                    logger.debug(`Skipping ${resolved} because a dist version is already registered`);
-                    return;
-                }
-            }
+  const directories: string[] = [];
+  const visited = new Set<string>();
+
+  const isTsEnvironment =
+    process.argv[1]?.endsWith('.ts') ||
+    process.argv[1]?.endsWith('.mts') ||
+    process.execArgv.some(
+      (arg) => arg.includes('tsx') || arg.includes('ts-node') || arg.includes('vitest'),
+    ) ||
+    process.env.VITEST === 'true' ||
+    process.env.NODE_ENV === 'test';
+
+  const addDir = (dir: string) => {
+    const resolved = path.resolve(dir);
+    if (!fs.existsSync(resolved)) {
+      logger.debug(`Command directory not found (skipping): ${resolved}`);
+      return;
+    }
 
-            if (isDist) {
-                const srcEquivalent1 = resolved.replace(path.sep + 'dist' + path.sep, path.sep);
-                const srcEquivalent2 = resolved.replace(path.sep + 'dist' + path.sep + 'src' + path.sep, path.sep + 'src' + path.sep);
-                if (visited.has(srcEquivalent1) || visited.has(srcEquivalent2)) {
-                    // If we just added src, and now we find dist, we should actually REPLACE src with dist
-                    // but for now, the loop order prefers dist, so this case shouldn't happen much.
-                    // However, let's keep it simple.
-                    logger.debug(`Skipping ${resolved} because a src version is already registered`);
-                    return;
-                }
-            }
+    if (visited.has(resolved)) return;
+
+    // Detect if this is a source command directory
+    const srcPattern = path.join(path.sep, 'src', 'commands');
+    const distPattern = path.join(path.sep, 'dist');
+    const isSrcDir = resolved.endsWith(srcPattern) && !resolved.includes(distPattern);
+
+    // Strict check: if we are adding a 'src' directory...
+    if (isSrcDir) {
+      // 1. Check if an equivalent 'dist' exists in the same package
+      const distPath1 = resolved.replace(
+        srcPattern,
+        path.join(path.sep, 'dist', 'src', 'commands'),
+      );
+      const distPath2 = resolved.replace(srcPattern, path.join(path.sep, 'dist', 'commands'));
+
+      if (fs.existsSync(distPath1) || fs.existsSync(distPath2)) {
+        logger.debug(`Skipping src commands at ${resolved} because dist exists`);
+        return;
+      }
+
+      // 2. If no TS loader, skip src/commands entirely IF it's likely to contain .ts
+      if (!isTsEnvironment) {
+        logger.debug(`Skipping src commands at ${resolved}: no TS loader detected`);
+        return;
+      }
+    }
 
-            logger.debug(`Found command directory: ${resolved}`);
-            directories.push(resolved);
-            visited.add(resolved);
-        } else {
-            logger.debug(`Command directory not found (skipping): ${resolved}`);
-        }
-    };
-
-    // 1. Core commands
-    // Search in projectRoot
-    const possibleCorePaths = [
-        path.join(projectRoot, 'src/commands'),
-    ];
-
-    possibleCorePaths.forEach(addDir);
-
-    // 2. Module commands
-    const possibleModuleDirs = [
-        path.join(projectRoot, 'modules'),
-        path.join(projectRoot, 'src', 'modules') // Support both flat and src-nested
-    ];
-
-    possibleModuleDirs.forEach(modulesDir => {
-        if (fs.existsSync(modulesDir)) {
-            try {
-                const modules = fs.readdirSync(modulesDir);
-                for (const mod of modules) {
-                    // exclude system files/dirs like .keep
-                    if (mod.startsWith('.')) continue;
-
-                    const modPath = path.join(modulesDir, mod);
-                    if (!fs.statSync(modPath).isDirectory()) continue;
-
-                    // Check for commands inside the module/package
-                    // Order matters: prefer dist if it exists
-                    const possibleCmdPaths = [
-                        path.join(modPath, 'dist/src/commands'),
-                        path.join(modPath, 'dist/commands'),
-                        path.join(modPath, 'src/commands')
-                    ];
-
-                    for (const cmdPath of possibleCmdPaths) {
-                        if (fs.existsSync(cmdPath) && fs.statSync(cmdPath).isDirectory()) {
-                            addDir(cmdPath);
-                        }
-                    }
-                }
-            } catch (e: any) {
-                logger.debug(`Error scanning modules directory ${modulesDir}: ${e.message}`);
+    logger.debug(`Found command directory: ${resolved}`);
+    directories.push(resolved);
+    visited.add(resolved);
+  };
+
+  // 1. Core commands
+  const possibleCorePaths = [path.join(projectRoot, 'src/commands')];
+  possibleCorePaths.forEach(addDir);
+
+  // 2. Module & Package commands
+  const searchRoots = [
+    path.join(projectRoot, 'modules'),
+    path.join(projectRoot, 'src', 'modules'),
+    path.join(projectRoot, 'packages'),
+  ];
+
+  searchRoots.forEach((root) => {
+    if (!fs.existsSync(root)) return;
+    try {
+      const entries = fs.readdirSync(root);
+      for (const entry of entries) {
+        if (entry.startsWith('.')) continue;
+        const entryPath = path.join(root, entry);
+        if (!fs.statSync(entryPath).isDirectory()) continue;
+
+        // Preference: dist/src/commands > dist/commands > src/commands
+        const possiblePaths = [
+          path.join(entryPath, 'dist/src/commands'),
+          path.join(entryPath, 'dist/commands'),
+          path.join(entryPath, 'src/commands'),
+        ];
+
+        let foundDist = false;
+        for (const p of possiblePaths) {
+          if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
+            if (p.includes(path.sep + 'dist' + path.sep)) {
+              addDir(p);
+              foundDist = true;
+              break; // Found a dist version, skip others for this entry
             }
+          }
         }
-    });
-
-    // 3. Package commands (e.g. packages/*)
-    const packagesDir = path.join(projectRoot, 'packages');
-    if (fs.existsSync(packagesDir)) {
-        try {
-            const packages = fs.readdirSync(packagesDir);
-            for (const pkg of packages) {
-                if (pkg.startsWith('.')) continue;
-
-                const pkgPath = path.join(packagesDir, pkg);
-                if (!fs.statSync(pkgPath).isDirectory()) continue;
-
-                const possibleCmdPaths = [
-                    path.join(pkgPath, 'dist/src/commands'),
-                    path.join(pkgPath, 'dist/commands'),
-                    path.join(pkgPath, 'src/commands')
-                ];
-
-                for (const cmdPath of possibleCmdPaths) {
-                    if (fs.existsSync(cmdPath) && fs.statSync(cmdPath).isDirectory()) {
-                        addDir(cmdPath);
-                    }
-                }
-            }
-        } catch (e: any) {
-            logger.debug(`Error scanning packages directory: ${e.message}`);
+
+        if (!foundDist) {
+          const srcPath = path.join(entryPath, 'src/commands');
+          if (fs.existsSync(srcPath) && fs.statSync(srcPath).isDirectory()) {
+            addDir(srcPath);
+          }
         }
+      }
+    } catch (e: unknown) {
+      logger.debug(`Error scanning root ${root}: ${e instanceof Error ? e.message : String(e)}`);
     }
+  });
 
-    return directories;
+  return directories;
 }