@nexical/cli 0.10.0 → 0.11.1

package/src/commands/init.ts

@@ -5,81 +5,85 @@ import fs from 'fs-extra';
 import path from 'path';
 
 export default class InitCommand extends BaseCommand {
-    static usage = 'init';
-    static description = 'Initialize a new Nexical project.';
-    static requiresProject = false;
-
-    static args: CommandDefinition = {
-        args: [
-            { name: 'directory', required: true, description: 'Directory to initialize the project in' }
-        ],
-        options: [
-            {
-                name: '--repo <url>',
-                description: 'Starter repository URL (supports gh@owner/repo syntax)',
-                default: 'gh@nexical/app-core'
-            }
-        ]
-    };
-
-    async run(options: any) {
-        const directory = options.directory;
-        const targetPath = path.resolve(process.cwd(), directory);
-        let repoUrl = resolveGitUrl(options.repo);
-
-        logger.debug('Init options:', { directory, targetPath, repoUrl });
-
-        this.info(`Initializing project in: ${targetPath}`);
-        this.info(`Using starter repository: ${repoUrl}`);
-
-        if (await fs.pathExists(targetPath)) {
-            if ((await fs.readdir(targetPath)).length > 0) {
-                this.error(`Directory ${directory} is not empty.`);
-                process.exit(1);
-            }
-        } else {
-            await fs.mkdir(targetPath, { recursive: true });
-        }
-
-        try {
-            this.info('Cloning core repository...');
-            await git.clone(repoUrl, targetPath, { recursive: true });
-
-            this.info('Updating submodules...');
-            await git.updateSubmodules(targetPath);
-
-            this.info('Installing dependencies...');
-            await runCommand('npm install', targetPath);
-
-            this.info('Setting up upstream remote...');
-            await git.renameRemote('origin', 'upstream', targetPath);
-
-            // Ensure module directory
-            await fs.ensureDir(path.join(targetPath, 'modules'));
-
-            // Check for nexical.yaml, if not present create a default one
-            const configPath = path.join(targetPath, 'nexical.yaml');
-            if (!await fs.pathExists(configPath)) {
-                this.info('Creating default nexical.yaml...');
-                await fs.writeFile(configPath, 'name: ' + path.basename(targetPath) + '\nmodules: []\n');
-            }
-
-            // Create VERSION file
-            const versionPath = path.join(targetPath, 'VERSION');
-            // Check if version file exists, if not create it
-            if (!await fs.pathExists(versionPath)) {
-                this.info('Creating VERSION file with 0.1.0...');
-                await fs.writeFile(versionPath, '0.1.0');
-            }
-
-            await git.addAll(targetPath);
-            await git.commit('Initial site commit', targetPath);
-
-            this.success(`Project initialized successfully in ${directory}!`);
+  static usage = 'init';
+  static description = 'Initialize a new Nexical project.';
+  static requiresProject = false;
+
+  static args: CommandDefinition = {
+    args: [
+      { name: 'directory', required: true, description: 'Directory to initialize the project in' },
+    ],
+    options: [
+      {
+        name: '--repo <url>',
+        description: 'Starter repository URL (supports gh@owner/repo syntax)',
+        default: 'gh@nexical/app-starter',
+      },
+    ],
+  };
+
+  async run(options: { directory: string; repo: string }) {
+    const directory = options.directory;
+    const targetPath = path.resolve(process.cwd(), directory);
+    const repoUrl = resolveGitUrl(options.repo);
+
+    logger.debug('Init options:', { directory, targetPath, repoUrl });
+
+    this.info(`Initializing project in: ${targetPath}`);
+    this.info(`Using starter repository: ${repoUrl}`);
+
+    if (await fs.pathExists(targetPath)) {
+      if ((await fs.readdir(targetPath)).length > 0) {
+        this.error(`Directory ${directory} is not empty.`);
+        process.exit(1);
+      }
+    } else {
+      await fs.mkdir(targetPath, { recursive: true });
+    }
 
-        } catch (error: any) {
-            this.error(`Failed to initialize project: ${error.message}`);
-            process.exit(1);
-        }
+    try {
+      this.info('Cloning starter repository...');
+      await git.clone(repoUrl, targetPath, { recursive: true });
+
+      this.info('Updating submodules...');
+      await git.updateSubmodules(targetPath);
+
+      this.info('Installing dependencies...');
+      await runCommand('npm install', targetPath);
+
+      this.info('Setting up upstream remote...');
+      await git.renameRemote('origin', 'upstream', targetPath);
+
+      // Run setup script
+      this.info('Running project setup...');
+      await runCommand('npm run setup', targetPath);
+
+      // Check for nexical.yaml, if not present create a default one
+      const configPath = path.join(targetPath, 'nexical.yaml');
+      if (!(await fs.pathExists(configPath))) {
+        this.info('Creating default nexical.yaml...');
+        await fs.writeFile(configPath, 'name: ' + path.basename(targetPath) + '\nmodules: []\n');
+      }
+
+      // Create VERSION file
+      const versionPath = path.join(targetPath, 'VERSION');
+      // Check if version file exists, if not create it
+      if (!(await fs.pathExists(versionPath))) {
+        this.info('Creating VERSION file with 0.1.0...');
+        await fs.writeFile(versionPath, '0.1.0');
+      }
+
+      await git.addAll(targetPath);
+      await git.commit('Initial site commit', targetPath);
+
+      this.success(`Project initialized successfully in ${directory}!`);
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        this.error(`Failed to initialize project: ${error.message}`);
+      } else {
+        this.error(`Failed to initialize project: ${String(error)}`);
+      }
+      process.exit(1);
     }
+  }
 }

package/src/commands/module/add.ts

@@ -6,164 +6,174 @@ import { resolveGitUrl } from '../../utils/url-resolver.js';
 import YAML from 'yaml';
 
 export default class ModuleAddCommand extends BaseCommand {
-    static usage = 'module add <url>';
-    static description = 'Add a module and its dependencies as git submodules.';
-    static requiresProject = true;
+  static usage = 'module add <url>';
+  static description = 'Add a module and its dependencies as git submodules.';
+  static requiresProject = true;
 
-    static args: CommandDefinition = {
-        args: [
-            { name: 'url', required: true, description: 'Git repository URL or gh@org/repo' }
-        ]
-    };
+  static args: CommandDefinition = {
+    args: [{ name: 'url', required: true, description: 'Git repository URL or gh@org/repo' }],
+  };
 
-    private visited = new Set<string>();
+  private visited = new Set<string>();
 
-    async run(options: any) {
-        const projectRoot = this.projectRoot as string;
-        let { url } = options;
+  async run(options: { url: string }) {
+    const projectRoot = this.projectRoot as string;
+    const { url } = options;
 
-        if (!url) {
-            this.error('Please specify a repository URL.');
-            return;
-        }
+    if (!url) {
+      this.error('Please specify a repository URL.');
+      return;
+    }
+
+    try {
+      await this.installModule(url);
 
-        try {
-            await this.installModule(url);
+      this.info('Syncing workspace dependencies...');
+      await runCommand('npm install', projectRoot);
+
+      this.success('All modules installed successfully.');
+    } catch (e: unknown) {
+      if (e instanceof Error) {
+        this.error(`Failed to add module: ${e.message}`);
+      } else {
+        this.error(`Failed to add module: ${String(e)}`);
+      }
+    }
+  }
 
-            this.info('Syncing workspace dependencies...');
-            await runCommand('npm install', projectRoot);
+  private async installModule(url: string) {
+    const projectRoot = this.projectRoot as string;
 
-            this.success('All modules installed successfully.');
-        } catch (e: any) {
-            this.error(`Failed to add module: ${e.message}`);
-        }
+    // Resolve URL using utility
+    url = resolveGitUrl(url);
+
+    const [repoUrl, subPath] = url.split('.git//');
+    const cleanUrl = subPath ? repoUrl + '.git' : url;
+
+    if (this.visited.has(cleanUrl)) {
+      logger.debug(`Already visited ${cleanUrl}, skipping.`);
+      return;
+    }
+    this.visited.add(cleanUrl);
+
+    this.info(`Inspecting ${cleanUrl}...`);
+
+    // Stage 1: Inspect (Temp Clone)
+    const stagingDir = path.resolve(
+      projectRoot!,
+      '.nexical',
+      'cache',
+      `staging-${Date.now()}-${Math.random().toString(36).substring(7)}`,
+    );
+    let moduleName = '';
+    let dependencies: string[] = [];
+
+    try {
+      await fs.ensureDir(stagingDir);
+
+      // Shallow clone to inspect
+      await clone(cleanUrl, stagingDir, { depth: 1 });
+
+      // Read module.yaml
+      const searchPath = subPath ? path.join(stagingDir, subPath) : stagingDir;
+      const moduleYamlPath = path.join(searchPath, 'module.yaml');
+      const moduleYmlPath = path.join(searchPath, 'module.yml');
+
+      let configPath = '';
+      if (await fs.pathExists(moduleYamlPath)) configPath = moduleYamlPath;
+      else if (await fs.pathExists(moduleYmlPath)) configPath = moduleYmlPath;
+      else {
+        throw new Error(`No module.yaml found in ${cleanUrl}${subPath ? '//' + subPath : ''}`);
+      }
+
+      const configContent = await fs.readFile(configPath, 'utf8');
+      const config = YAML.parse(configContent);
+
+      if (!config.name) {
+        throw new Error(`Module at ${url} is missing 'name' in module.yaml`);
+      }
+      moduleName = config.name;
+      dependencies = config.dependencies || [];
+
+      // Normalize dependencies to array if object (though spec says list of strings, defensiveness is good)
+      if (dependencies && !Array.isArray(dependencies)) {
+        dependencies = Object.keys(dependencies);
+      }
+    } finally {
+      // Cleanup staging always
+      await fs.remove(stagingDir);
     }
 
-    private async installModule(url: string) {
-        const projectRoot = this.projectRoot as string;
-
-        // Resolve URL using utility
-        url = resolveGitUrl(url);
-
-        const [repoUrl, subPath] = url.split('.git//');
-        const cleanUrl = subPath ? repoUrl + '.git' : url;
-
-        if (this.visited.has(cleanUrl)) {
-            logger.debug(`Already visited ${cleanUrl}, skipping.`);
-            return;
-        }
-        this.visited.add(cleanUrl);
-
-        this.info(`Inspecting ${cleanUrl}...`);
-
-        // Stage 1: Inspect (Temp Clone)
-        const stagingDir = path.resolve(projectRoot!, '.nexical', 'cache', `staging-${Date.now()}-${Math.random().toString(36).substring(7)}`);
-        let moduleName = '';
-        let dependencies: string[] = [];
-
-        try {
-            await fs.ensureDir(stagingDir);
-
-            // Shallow clone to inspect
-            await clone(cleanUrl, stagingDir, { depth: 1 });
-
-            // Read module.yaml
-            const searchPath = subPath ? path.join(stagingDir, subPath) : stagingDir;
-            const moduleYamlPath = path.join(searchPath, 'module.yaml');
-            const moduleYmlPath = path.join(searchPath, 'module.yml');
-
-            let configPath = '';
-            if (await fs.pathExists(moduleYamlPath)) configPath = moduleYamlPath;
-            else if (await fs.pathExists(moduleYmlPath)) configPath = moduleYmlPath;
-            else {
-                throw new Error(`No module.yaml found in ${cleanUrl}${subPath ? '//' + subPath : ''}`);
-            }
-
-            const configContent = await fs.readFile(configPath, 'utf8');
-            const config = YAML.parse(configContent);
-
-            if (!config.name) {
-                throw new Error(`Module at ${url} is missing 'name' in module.yaml`);
-            }
-            moduleName = config.name;
-            dependencies = config.dependencies || [];
-
-            // Normalize dependencies to array if object (though spec says list of strings, defensiveness is good)
-            if (dependencies && !Array.isArray(dependencies)) {
-                dependencies = Object.keys(dependencies);
-            }
-
-        } catch (e: any) { // Catching as 'any' for error message access
-            throw e;
-        } finally {
-            // Cleanup staging always
-            await fs.remove(stagingDir);
-        }
-
-        // Stage 2: Conflict Detection
-        const targetDir = path.join(projectRoot!, 'modules', moduleName);
-        const relativeTargetDir = path.relative(projectRoot!, targetDir);
-
-        if (await fs.pathExists(targetDir)) {
-            // Check origin
-            const existingRemote = await getRemoteUrl(targetDir);
-            // We compare cleanUrl (the repo root).
-            // normalize both
-            const normExisting = existingRemote.replace(/\.git$/, '');
-            const normNew = cleanUrl.replace(/\.git$/, '');
-
-            if (normExisting !== normNew && existingRemote !== '') {
-                throw new Error(`Dependency Conflict! Module '${moduleName}' exists but remote '${existingRemote}' does not match '${cleanUrl}'.`);
-            }
-
-            this.info(`Module ${moduleName} already installed.`);
-            // Proceed to recurse, but skip add
-        } else {
-            // Stage 3: Submodule Add
-            this.info(`Installing ${moduleName} to ${relativeTargetDir}...`);
-            // We install the ROOT repo.
-            // IMPORTANT: If subPath exists, "Identity is Internal" means we name the folder `moduleName`.
-            // But the CONTENT will be the whole repo.
-            // If the user meant to only have the subdir, we can't do that with submodule add easily without manual git plumbing.
-            // Given instructions, I will proceed with submodule add of root repo to target dir.
-            await runCommand(`git submodule add ${cleanUrl} ${relativeTargetDir}`, projectRoot!);
-        }
-
-        // Update nexical.yaml
-        await this.addToConfig(moduleName);
-
-        // Stage 4: Recurse
-        if (dependencies.length > 0) {
-            this.info(`Resolving ${dependencies.length} dependencies for ${moduleName}...`);
-            for (const depUrl of dependencies) {
-                await this.installModule(depUrl);
-            }
-        }
+    // Stage 2: Conflict Detection
+    const targetDir = path.join(projectRoot!, 'modules', moduleName);
+    const relativeTargetDir = path.relative(projectRoot!, targetDir);
+
+    if (await fs.pathExists(targetDir)) {
+      // Check origin
+      const existingRemote = await getRemoteUrl(targetDir);
+      // We compare cleanUrl (the repo root).
+      // normalize both
+      const normExisting = existingRemote.replace(/\.git$/, '');
+      const normNew = cleanUrl.replace(/\.git$/, '');
+
+      if (normExisting !== normNew && existingRemote !== '') {
+        throw new Error(
+          `Dependency Conflict! Module '${moduleName}' exists but remote '${existingRemote}' does not match '${cleanUrl}'.`,
+        );
+      }
+
+      this.info(`Module ${moduleName} already installed.`);
+      // Proceed to recurse, but skip add
+    } else {
+      // Stage 3: Submodule Add
+      this.info(`Installing ${moduleName} to ${relativeTargetDir}...`);
+      // We install the ROOT repo.
+      // IMPORTANT: If subPath exists, "Identity is Internal" means we name the folder `moduleName`.
+      // But the CONTENT will be the whole repo.
+      // If the user meant to only have the subdir, we can't do that with submodule add easily without manual git plumbing.
+      // Given instructions, I will proceed with submodule add of root repo to target dir.
+      await runCommand(`git submodule add ${cleanUrl} ${relativeTargetDir}`, projectRoot!);
+    }
+
+    // Update nexical.yaml
+    await this.addToConfig(moduleName);
+
+    // Stage 4: Recurse
+    if (dependencies.length > 0) {
+      this.info(`Resolving ${dependencies.length} dependencies for ${moduleName}...`);
+      for (const depUrl of dependencies) {
+        await this.installModule(depUrl);
+      }
+    }
+  }
+
+  private async addToConfig(moduleName: string) {
+    const projectRoot = this.projectRoot as string;
+    const configPath = path.join(projectRoot, 'nexical.yaml');
+
+    if (!(await fs.pathExists(configPath))) {
+      // Not strictly required to exist for all operations, but good to have if we are tracking modules.
+      logger.warn('nexical.yaml not found, skipping module list update.');
+      return;
     }
 
-    private async addToConfig(moduleName: string) {
-        const projectRoot = this.projectRoot as string;
-        const configPath = path.join(projectRoot, 'nexical.yaml');
-
-        if (!await fs.pathExists(configPath)) {
-            // Not strictly required to exist for all operations, but good to have if we are tracking modules.
-            logger.warn('nexical.yaml not found, skipping module list update.');
-            return;
-        }
-
-        try {
-            const content = await fs.readFile(configPath, 'utf8');
-            let config = YAML.parse(content) || {};
-
-            if (!config.modules) config.modules = [];
-
-            if (!config.modules.includes(moduleName)) {
-                config.modules.push(moduleName);
-                await fs.writeFile(configPath, YAML.stringify(config));
-                logger.debug(`Added ${moduleName} to nexical.yaml modules list.`);
-            }
-        } catch (e: any) {
-            logger.warn(`Failed to update nexical.yaml: ${e.message}`);
-        }
+    try {
+      const content = await fs.readFile(configPath, 'utf8');
+      const config = YAML.parse(content) || {};
+
+      if (!config.modules) config.modules = [];
+
+      if (!config.modules.includes(moduleName)) {
+        config.modules.push(moduleName);
+        await fs.writeFile(configPath, YAML.stringify(config));
+        logger.debug(`Added ${moduleName} to 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/list.ts

@@ -4,66 +4,77 @@ import path from 'path';
 import YAML from 'yaml';
 
 export default class ModuleListCommand extends BaseCommand {
-    static usage = 'module list';
-    static description = 'List installed modules.';
-    static requiresProject = true;
+  static usage = 'module list';
+  static description = 'List installed modules.';
+  static requiresProject = true;
 
-    async run() {
-        const projectRoot = this.projectRoot as string;
-        const modulesDir = path.resolve(projectRoot, 'modules');
-        logger.debug(`Scanning for modules in: ${modulesDir}`);
+  async run() {
+    const projectRoot = this.projectRoot as string;
+    const modulesDir = path.resolve(projectRoot, 'modules');
+    logger.debug(`Scanning for modules in: ${modulesDir}`);
 
-        if (!(await fs.pathExists(modulesDir))) {
-            this.info('No modules installed (modules directory missing).');
-            return;
-        }
-
-        try {
-            const modules = await fs.readdir(modulesDir);
-            const validModules: { name: string; version: string; description: string }[] = [];
-
-            for (const moduleName of modules) {
-                const modulePath = path.join(modulesDir, moduleName);
-                if ((await fs.stat(modulePath)).isDirectory()) {
-                    let version = 'unknown';
-                    let description = '';
+    if (!(await fs.pathExists(modulesDir))) {
+      this.info('No modules installed (modules directory missing).');
+      return;
+    }
 
-                    const pkgJsonPath = path.join(modulePath, 'package.json');
-                    const moduleYamlPath = path.join(modulePath, 'module.yaml');
-                    const moduleYmlPath = path.join(modulePath, 'module.yml');
+    try {
+      const modules = await fs.readdir(modulesDir);
+      const validModules: { name: string; version: string; description: string }[] = [];
 
-                    let pkg: any = {};
-                    let modConfig: any = {};
+      for (const moduleName of modules) {
+        const modulePath = path.join(modulesDir, moduleName);
+        if ((await fs.stat(modulePath)).isDirectory()) {
+          let version = 'unknown';
+          let description = '';
 
-                    if (await fs.pathExists(pkgJsonPath)) {
-                        try {
-                            pkg = await fs.readJson(pkgJsonPath);
-                        } catch (e) { /* ignore */ }
-                    }
+          const pkgJsonPath = path.join(modulePath, 'package.json');
+          const moduleYamlPath = path.join(modulePath, 'module.yaml');
+          const moduleYmlPath = path.join(modulePath, 'module.yml');
 
-                    if (await fs.pathExists(moduleYamlPath) || await fs.pathExists(moduleYmlPath)) {
-                        try {
-                            const configPath = await fs.pathExists(moduleYamlPath) ? moduleYamlPath : moduleYmlPath;
-                            const content = await fs.readFile(configPath, 'utf8');
-                            modConfig = YAML.parse(content) || {};
-                        } catch (e) { /* ignore */ }
-                    }
+          let pkg: Record<string, unknown> = {};
+          let modConfig: Record<string, unknown> = {};
 
-                    version = pkg.version || 'unknown';
-                    description = modConfig.description || pkg.description || '';
-                    // Optionally use display name from module.yaml if present, but strictly list is usually dir name.
-                    // Let's stick to dir name for "name" column, but description from module.yaml is good.
-                    validModules.push({ name: moduleName, version, description });
-                }
+          if (await fs.pathExists(pkgJsonPath)) {
+            try {
+              pkg = await fs.readJson(pkgJsonPath);
+            } catch {
+              /* ignore */
             }
+          }
 
-            if (validModules.length === 0) {
-                this.info('No modules installed.');
-            } else {
-                console.table(validModules);
+          if ((await fs.pathExists(moduleYamlPath)) || (await fs.pathExists(moduleYmlPath))) {
+            try {
+              const configPath = (await fs.pathExists(moduleYamlPath))
+                ? moduleYamlPath
+                : moduleYmlPath;
+              const content = await fs.readFile(configPath, 'utf8');
+              modConfig = YAML.parse(content) || {};
+            } catch {
+              /* ignore */
             }
-        } catch (error: any) {
-            this.error(`Failed to list modules: ${error.message}`);
+          }
+
+          version = (pkg.version as string) || (modConfig.version as string) || 'unknown';
+          description = (pkg.description as string) || (modConfig.description as string) || '';
+          // Optionally use display name from module.yaml if present, but strictly list is usually dir name.
+          // Let's stick to dir name for "name" column, but description from module.yaml is good.
+          validModules.push({ name: moduleName, version, description });
         }
+      }
+
+      if (validModules.length === 0) {
+        this.info('No modules installed.');
+      } else {
+        // eslint-disable-next-line no-console
+        console.table(validModules);
+      }
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        this.error(`Failed to list modules: ${error.message}`);
+      } else {
+        this.error(`Failed to list modules: ${String(error)}`);
+      }
     }
+  }
 }