@nexical/cli 0.1.7 → 0.11.0

package/dist/index.js

@@ -1,14 +1,21 @@
 #!/usr/bin/env node
 import { createRequire } from "module"; const require = createRequire(import.meta.url);
+import {
+  discoverCommandDirectories
+} from "./chunk-OKXOCNXP.js";
+import {
+  init_esm_shims
+} from "./chunk-OYFWMYPG.js";
 
 // index.ts
-import { CLI } from "@nexical/cli-core";
+init_esm_shims();
+import { CLI, findProjectRoot } from "@nexical/cli-core";
 import { fileURLToPath } from "url";
 
 // package.json
 var package_default = {
   name: "@nexical/cli",
-  version: "0.1.7",
+  version: "0.11.0",
   type: "module",
   bin: {
     nexical: "./dist/index.js"
@@ -25,7 +32,8 @@ var package_default = {
   },
   dependencies: {
     "@nexical/cli-core": "^0.1.12",
-    "@nexical/sdk": "^0.4.2"
+    yaml: "^2.3.4",
+    "fast-glob": "^3.3.3"
   },
   devDependencies: {
     "@types/fs-extra": "^11.0.4",
@@ -34,6 +42,7 @@ var package_default = {
     execa: "^9.6.1",
     "fs-extra": "^11.3.2",
     tsup: "^8.0.1",
+    tsx: "^4.21.0",
     typescript: "^5.3.3",
     vitest: "^4.0.15"
   }
@@ -42,10 +51,28 @@ var package_default = {
 // index.ts
 import path from "path";
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var commandName = "nexical";
+var projectRoot = await findProjectRoot(commandName, process.cwd()) || process.cwd();
+var coreCommandsDir = path.resolve(__dirname, "./src/commands");
+var additionalCommands = discoverCommandDirectories(projectRoot);
+var filteredAdditional = additionalCommands.filter((dir) => {
+  if (dir === coreCommandsDir) return false;
+  if (coreCommandsDir.includes(path.join(path.sep, "dist", "src", "commands"))) {
+    const srcVersion = coreCommandsDir.replace(
+      path.join(path.sep, "dist", "src", "commands"),
+      path.join(path.sep, "src", "commands")
+    );
+    if (dir === srcVersion) return false;
+  }
+  return true;
+});
 var app = new CLI({
   version: package_default.version,
-  commandName: "nexical",
-  searchDirectories: [path.resolve(__dirname, "./src/commands")]
+  commandName,
+  searchDirectories: [.../* @__PURE__ */ new Set([
+    coreCommandsDir,
+    ...filteredAdditional
+  ])]
 });
 app.start();
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../index.ts","../package.json"],"sourcesContent":["#!/usr/bin/env node\nimport { CLI } from \"@nexical/cli-core\";\nimport { fileURLToPath } from \"node:url\";\nimport pkg from './package.json';\nimport path from 'node:path';\n\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\nconst app = new CLI({\n  version: pkg.version,\n  commandName: \"nexical\",\n  searchDirectories: [path.resolve(__dirname, \"./src/commands\")],\n});\napp.start();\n","{\n  \"name\": \"@nexical/cli\",\n  \"version\": \"0.1.7\",\n  \"type\": \"module\",\n  \"bin\": {\n    \"nexical\": \"./dist/index.js\"\n  },\n  \"scripts\": {\n    \"build\": \"tsup\",\n    \"dev\": \"tsup --watch\",\n    \"start\": \"node dist/index.js\",\n    \"test\": \"npm run test:unit && npm run test:integration && npm run test:e2e\",\n    \"test:unit\": \"vitest run --config vitest.config.ts --coverage\",\n    \"test:integration\": \"vitest run --config vitest.integration.config.ts\",\n    \"test:e2e\": \"npm run build && vitest run --config vitest.e2e.config.ts\",\n    \"test:watch\": \"vitest\"\n  },\n  \"dependencies\": {\n    \"@nexical/cli-core\": \"^0.1.12\",\n    \"@nexical/sdk\": \"^0.4.2\"\n  },\n  \"devDependencies\": {\n    \"@types/fs-extra\": \"^11.0.4\",\n    \"@types/node\": \"^20.10.0\",\n    \"@vitest/coverage-v8\": \"^4.0.15\",\n    \"execa\": \"^9.6.1\",\n    \"fs-extra\": \"^11.3.2\",\n    \"tsup\": \"^8.0.1\",\n    \"typescript\": \"^5.3.3\",\n    \"vitest\": \"^4.0.15\"\n  }\n}\n"],"mappings":";;;;AACA,SAAS,WAAW;AACpB,SAAS,qBAAqB;;;ACF9B;AAAA,EACE,MAAQ;AAAA,EACR,SAAW;AAAA,EACX,MAAQ;AAAA,EACR,KAAO;AAAA,IACL,SAAW;AAAA,EACb;AAAA,EACA,SAAW;AAAA,IACT,OAAS;AAAA,IACT,KAAO;AAAA,IACP,OAAS;AAAA,IACT,MAAQ;AAAA,IACR,aAAa;AAAA,IACb,oBAAoB;AAAA,IACpB,YAAY;AAAA,IACZ,cAAc;AAAA,EAChB;AAAA,EACA,cAAgB;AAAA,IACd,qBAAqB;AAAA,IACrB,gBAAgB;AAAA,EAClB;AAAA,EACA,iBAAmB;AAAA,IACjB,mBAAmB;AAAA,IACnB,eAAe;AAAA,IACf,uBAAuB;AAAA,IACvB,OAAS;AAAA,IACT,YAAY;AAAA,IACZ,MAAQ;AAAA,IACR,YAAc;AAAA,IACd,QAAU;AAAA,EACZ;AACF;;;AD3BA,OAAO,UAAU;AAEjB,IAAM,YAAY,KAAK,QAAQ,cAAc,YAAY,GAAG,CAAC;AAE7D,IAAM,MAAM,IAAI,IAAI;AAAA,EAClB,SAAS,gBAAI;AAAA,EACb,aAAa;AAAA,EACb,mBAAmB,CAAC,KAAK,QAAQ,WAAW,gBAAgB,CAAC;AAC/D,CAAC;AACD,IAAI,MAAM;","names":[]}
+{"version":3,"sources":["../index.ts","../package.json"],"sourcesContent":["#!/usr/bin/env node\nimport { CLI, findProjectRoot } from '@nexical/cli-core';\nimport { fileURLToPath } from 'node:url';\nimport { discoverCommandDirectories } from './src/utils/discovery.js';\nimport pkg from './package.json';\nimport path from 'node:path';\n\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\n\nconst commandName = 'nexical';\nconst projectRoot = await findProjectRoot(commandName, process.cwd()) || process.cwd();\nconst coreCommandsDir = path.resolve(__dirname, './src/commands');\nconst additionalCommands = discoverCommandDirectories(projectRoot);\n\n// Filter out the source version of core commands if we are running from dist\nconst filteredAdditional = additionalCommands.filter(dir => {\n    if (dir === coreCommandsDir) return false;\n\n    // Handle the case where we are running from dist/ and it finds src/commands in projectRoot\n    if (coreCommandsDir.includes(path.join(path.sep, 'dist', 'src', 'commands'))) {\n        const srcVersion = coreCommandsDir.replace(\n            path.join(path.sep, 'dist', 'src', 'commands'),\n            path.join(path.sep, 'src', 'commands')\n        );\n        if (dir === srcVersion) return false;\n    }\n    return true;\n});\n\nconst app = new CLI({\n    version: pkg.version,\n    commandName: commandName,\n    searchDirectories: [...new Set([\n        coreCommandsDir,\n        ...filteredAdditional\n    ])]\n});\napp.start();\n","{\n    \"name\": \"@nexical/cli\",\n    \"version\": \"0.11.0\",\n    \"type\": \"module\",\n    \"bin\": {\n        \"nexical\": \"./dist/index.js\"\n    },\n    \"scripts\": {\n        \"build\": \"tsup\",\n        \"dev\": \"tsup --watch\",\n        \"start\": \"node dist/index.js\",\n        \"test\": \"npm run test:unit && npm run test:integration && npm run test:e2e\",\n        \"test:unit\": \"vitest run --config vitest.config.ts --coverage\",\n        \"test:integration\": \"vitest run --config vitest.integration.config.ts\",\n        \"test:e2e\": \"npm run build && vitest run --config vitest.e2e.config.ts\",\n        \"test:watch\": \"vitest\"\n    },\n    \"dependencies\": {\n        \"@nexical/cli-core\": \"^0.1.12\",\n        \"yaml\": \"^2.3.4\",\n        \"fast-glob\": \"^3.3.3\"\n    },\n    \"devDependencies\": {\n        \"@types/fs-extra\": \"^11.0.4\",\n        \"@types/node\": \"^20.10.0\",\n        \"@vitest/coverage-v8\": \"^4.0.15\",\n        \"execa\": \"^9.6.1\",\n        \"fs-extra\": \"^11.3.2\",\n        \"tsup\": \"^8.0.1\",\n        \"tsx\": \"^4.21.0\",\n        \"typescript\": \"^5.3.3\",\n        \"vitest\": \"^4.0.15\"\n    }\n}\n"],"mappings":";;;;;;;;;;AAAA;AACA,SAAS,KAAK,uBAAuB;AACrC,SAAS,qBAAqB;;;ACF9B;AAAA,EACI,MAAQ;AAAA,EACR,SAAW;AAAA,EACX,MAAQ;AAAA,EACR,KAAO;AAAA,IACH,SAAW;AAAA,EACf;AAAA,EACA,SAAW;AAAA,IACP,OAAS;AAAA,IACT,KAAO;AAAA,IACP,OAAS;AAAA,IACT,MAAQ;AAAA,IACR,aAAa;AAAA,IACb,oBAAoB;AAAA,IACpB,YAAY;AAAA,IACZ,cAAc;AAAA,EAClB;AAAA,EACA,cAAgB;AAAA,IACZ,qBAAqB;AAAA,IACrB,MAAQ;AAAA,IACR,aAAa;AAAA,EACjB;AAAA,EACA,iBAAmB;AAAA,IACf,mBAAmB;AAAA,IACnB,eAAe;AAAA,IACf,uBAAuB;AAAA,IACvB,OAAS;AAAA,IACT,YAAY;AAAA,IACZ,MAAQ;AAAA,IACR,KAAO;AAAA,IACP,YAAc;AAAA,IACd,QAAU;AAAA,EACd;AACJ;;;AD5BA,OAAO,UAAU;AAEjB,IAAM,YAAY,KAAK,QAAQ,cAAc,YAAY,GAAG,CAAC;AAE7D,IAAM,cAAc;AACpB,IAAM,cAAc,MAAM,gBAAgB,aAAa,QAAQ,IAAI,CAAC,KAAK,QAAQ,IAAI;AACrF,IAAM,kBAAkB,KAAK,QAAQ,WAAW,gBAAgB;AAChE,IAAM,qBAAqB,2BAA2B,WAAW;AAGjE,IAAM,qBAAqB,mBAAmB,OAAO,SAAO;AACxD,MAAI,QAAQ,gBAAiB,QAAO;AAGpC,MAAI,gBAAgB,SAAS,KAAK,KAAK,KAAK,KAAK,QAAQ,OAAO,UAAU,CAAC,GAAG;AAC1E,UAAM,aAAa,gBAAgB;AAAA,MAC/B,KAAK,KAAK,KAAK,KAAK,QAAQ,OAAO,UAAU;AAAA,MAC7C,KAAK,KAAK,KAAK,KAAK,OAAO,UAAU;AAAA,IACzC;AACA,QAAI,QAAQ,WAAY,QAAO;AAAA,EACnC;AACA,SAAO;AACX,CAAC;AAED,IAAM,MAAM,IAAI,IAAI;AAAA,EAChB,SAAS,gBAAI;AAAA,EACb;AAAA,EACA,mBAAmB,CAAC,GAAG,oBAAI,IAAI;AAAA,IAC3B;AAAA,IACA,GAAG;AAAA,EACP,CAAC,CAAC;AACN,CAAC;AACD,IAAI,MAAM;","names":[]}

package/dist/src/commands/init.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand, CommandDefinition } from '@nexical/cli-core';
+
+declare class InitCommand extends BaseCommand {
+    static usage: string;
+    static description: string;
+    static requiresProject: boolean;
+    static args: CommandDefinition;
+    run(options: any): Promise<void>;
+}
+
+export { InitCommand as default };

package/dist/src/commands/init.js

@@ -0,0 +1,89 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+import {
+  require_lib
+} from "../../chunk-LZ3YQWAR.js";
+import {
+  addAll,
+  clone,
+  commit,
+  renameRemote,
+  updateSubmodules
+} from "../../chunk-WKERTCM6.js";
+import {
+  resolveGitUrl
+} from "../../chunk-JYASTIIW.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "../../chunk-OYFWMYPG.js";
+
+// src/commands/init.ts
+init_esm_shims();
+import { BaseCommand, logger, runCommand } from "@nexical/cli-core";
+var import_fs_extra = __toESM(require_lib(), 1);
+import path from "path";
+var InitCommand = class extends BaseCommand {
+  static usage = "init";
+  static description = "Initialize a new Nexical project.";
+  static requiresProject = false;
+  static args = {
+    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) {
+    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 import_fs_extra.default.pathExists(targetPath)) {
+      if ((await import_fs_extra.default.readdir(targetPath)).length > 0) {
+        this.error(`Directory ${directory} is not empty.`);
+        process.exit(1);
+      }
+    } else {
+      await import_fs_extra.default.mkdir(targetPath, { recursive: true });
+    }
+    try {
+      this.info("Cloning starter repository...");
+      await clone(repoUrl, targetPath, { recursive: true });
+      this.info("Updating submodules...");
+      await updateSubmodules(targetPath);
+      this.info("Installing dependencies...");
+      await runCommand("npm install", targetPath);
+      this.info("Setting up upstream remote...");
+      await renameRemote("origin", "upstream", targetPath);
+      this.info("Running project setup...");
+      await runCommand("npm run setup", targetPath);
+      const configPath = path.join(targetPath, "nexical.yaml");
+      if (!await import_fs_extra.default.pathExists(configPath)) {
+        this.info("Creating default nexical.yaml...");
+        await import_fs_extra.default.writeFile(configPath, "name: " + path.basename(targetPath) + "\nmodules: []\n");
+      }
+      const versionPath = path.join(targetPath, "VERSION");
+      if (!await import_fs_extra.default.pathExists(versionPath)) {
+        this.info("Creating VERSION file with 0.1.0...");
+        await import_fs_extra.default.writeFile(versionPath, "0.1.0");
+      }
+      await addAll(targetPath);
+      await commit("Initial site commit", targetPath);
+      this.success(`Project initialized successfully in ${directory}!`);
+    } catch (error) {
+      this.error(`Failed to initialize project: ${error.message}`);
+      process.exit(1);
+    }
+  }
+};
+export {
+  InitCommand as default
+};
+//# sourceMappingURL=init.js.map

package/dist/src/commands/init.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/commands/init.ts"],"sourcesContent":["import { type CommandDefinition, BaseCommand, logger, runCommand } from '@nexical/cli-core';\nimport * as git from '../utils/git.js';\nimport { resolveGitUrl } from '../utils/url-resolver.js';\nimport fs from 'fs-extra';\nimport path from 'path';\n\nexport default class InitCommand extends BaseCommand {\n    static usage = 'init';\n    static description = 'Initialize a new Nexical project.';\n    static requiresProject = false;\n\n    static args: CommandDefinition = {\n        args: [\n            { name: 'directory', required: true, description: 'Directory to initialize the project in' }\n        ],\n        options: [\n            {\n                name: '--repo <url>',\n                description: 'Starter repository URL (supports gh@owner/repo syntax)',\n                default: 'gh@nexical/app-starter'\n            }\n        ]\n    };\n\n    async run(options: any) {\n        const directory = options.directory;\n        const targetPath = path.resolve(process.cwd(), directory);\n        let repoUrl = resolveGitUrl(options.repo);\n\n        logger.debug('Init options:', { directory, targetPath, repoUrl });\n\n        this.info(`Initializing project in: ${targetPath}`);\n        this.info(`Using starter repository: ${repoUrl}`);\n\n        if (await fs.pathExists(targetPath)) {\n            if ((await fs.readdir(targetPath)).length > 0) {\n                this.error(`Directory ${directory} is not empty.`);\n                process.exit(1);\n            }\n        } else {\n            await fs.mkdir(targetPath, { recursive: true });\n        }\n\n        try {\n            this.info('Cloning starter repository...');\n            await git.clone(repoUrl, targetPath, { recursive: true });\n\n            this.info('Updating submodules...');\n            await git.updateSubmodules(targetPath);\n\n            this.info('Installing dependencies...');\n            await runCommand('npm install', targetPath);\n\n            this.info('Setting up upstream remote...');\n            await git.renameRemote('origin', 'upstream', targetPath);\n\n            // Run setup script\n            this.info('Running project setup...');\n            await runCommand('npm run setup', targetPath);\n\n            // Check for nexical.yaml, if not present create a default one\n            const configPath = path.join(targetPath, 'nexical.yaml');\n            if (!await fs.pathExists(configPath)) {\n                this.info('Creating default nexical.yaml...');\n                await fs.writeFile(configPath, 'name: ' + path.basename(targetPath) + '\\nmodules: []\\n');\n            }\n\n            // Create VERSION file\n            const versionPath = path.join(targetPath, 'VERSION');\n            // Check if version file exists, if not create it\n            if (!await fs.pathExists(versionPath)) {\n                this.info('Creating VERSION file with 0.1.0...');\n                await fs.writeFile(versionPath, '0.1.0');\n            }\n\n            await git.addAll(targetPath);\n            await git.commit('Initial site commit', targetPath);\n\n            this.success(`Project initialized successfully in ${directory}!`);\n\n        } catch (error: any) {\n            this.error(`Failed to initialize project: ${error.message}`);\n            process.exit(1);\n        }\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA,SAAiC,aAAa,QAAQ,kBAAkB;AAGxE,sBAAe;AACf,OAAO,UAAU;AAEjB,IAAqB,cAArB,cAAyC,YAAY;AAAA,EACjD,OAAO,QAAQ;AAAA,EACf,OAAO,cAAc;AAAA,EACrB,OAAO,kBAAkB;AAAA,EAEzB,OAAO,OAA0B;AAAA,IAC7B,MAAM;AAAA,MACF,EAAE,MAAM,aAAa,UAAU,MAAM,aAAa,yCAAyC;AAAA,IAC/F;AAAA,IACA,SAAS;AAAA,MACL;AAAA,QACI,MAAM;AAAA,QACN,aAAa;AAAA,QACb,SAAS;AAAA,MACb;AAAA,IACJ;AAAA,EACJ;AAAA,EAEA,MAAM,IAAI,SAAc;AACpB,UAAM,YAAY,QAAQ;AAC1B,UAAM,aAAa,KAAK,QAAQ,QAAQ,IAAI,GAAG,SAAS;AACxD,QAAI,UAAU,cAAc,QAAQ,IAAI;AAExC,WAAO,MAAM,iBAAiB,EAAE,WAAW,YAAY,QAAQ,CAAC;AAEhE,SAAK,KAAK,4BAA4B,UAAU,EAAE;AAClD,SAAK,KAAK,6BAA6B,OAAO,EAAE;AAEhD,QAAI,MAAM,gBAAAA,QAAG,WAAW,UAAU,GAAG;AACjC,WAAK,MAAM,gBAAAA,QAAG,QAAQ,UAAU,GAAG,SAAS,GAAG;AAC3C,aAAK,MAAM,aAAa,SAAS,gBAAgB;AACjD,gBAAQ,KAAK,CAAC;AAAA,MAClB;AAAA,IACJ,OAAO;AACH,YAAM,gBAAAA,QAAG,MAAM,YAAY,EAAE,WAAW,KAAK,CAAC;AAAA,IAClD;AAEA,QAAI;AACA,WAAK,KAAK,+BAA+B;AACzC,YAAU,MAAM,SAAS,YAAY,EAAE,WAAW,KAAK,CAAC;AAExD,WAAK,KAAK,wBAAwB;AAClC,YAAU,iBAAiB,UAAU;AAErC,WAAK,KAAK,4BAA4B;AACtC,YAAM,WAAW,eAAe,UAAU;AAE1C,WAAK,KAAK,+BAA+B;AACzC,YAAU,aAAa,UAAU,YAAY,UAAU;AAGvD,WAAK,KAAK,0BAA0B;AACpC,YAAM,WAAW,iBAAiB,UAAU;AAG5C,YAAM,aAAa,KAAK,KAAK,YAAY,cAAc;AACvD,UAAI,CAAC,MAAM,gBAAAA,QAAG,WAAW,UAAU,GAAG;AAClC,aAAK,KAAK,kCAAkC;AAC5C,cAAM,gBAAAA,QAAG,UAAU,YAAY,WAAW,KAAK,SAAS,UAAU,IAAI,iBAAiB;AAAA,MAC3F;AAGA,YAAM,cAAc,KAAK,KAAK,YAAY,SAAS;AAEnD,UAAI,CAAC,MAAM,gBAAAA,QAAG,WAAW,WAAW,GAAG;AACnC,aAAK,KAAK,qCAAqC;AAC/C,cAAM,gBAAAA,QAAG,UAAU,aAAa,OAAO;AAAA,MAC3C;AAEA,YAAU,OAAO,UAAU;AAC3B,YAAU,OAAO,uBAAuB,UAAU;AAElD,WAAK,QAAQ,uCAAuC,SAAS,GAAG;AAAA,IAEpE,SAAS,OAAY;AACjB,WAAK,MAAM,iCAAiC,MAAM,OAAO,EAAE;AAC3D,cAAQ,KAAK,CAAC;AAAA,IAClB;AAAA,EACJ;AACJ;","names":["fs"]}

package/dist/src/commands/module/add.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand, CommandDefinition } from '@nexical/cli-core';
+
+declare class ModuleAddCommand extends BaseCommand {
+    static usage: string;
+    static description: string;
+    static requiresProject: boolean;
+    static args: CommandDefinition;
+    private visited;
+    run(options: any): Promise<void>;
+    private installModule;
+    private addToConfig;
+}
+
+export { ModuleAddCommand as default };

package/dist/src/commands/module/add.js

@@ -0,0 +1,136 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+import {
+  require_lib
+} from "../../../chunk-LZ3YQWAR.js";
+import {
+  clone,
+  getRemoteUrl
+} from "../../../chunk-WKERTCM6.js";
+import {
+  resolveGitUrl
+} from "../../../chunk-JYASTIIW.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "../../../chunk-OYFWMYPG.js";
+
+// src/commands/module/add.ts
+init_esm_shims();
+var import_fs_extra = __toESM(require_lib(), 1);
+import { BaseCommand, logger, runCommand } from "@nexical/cli-core";
+import path from "path";
+import YAML from "yaml";
+var ModuleAddCommand = class extends BaseCommand {
+  static usage = "module add <url>";
+  static description = "Add a module and its dependencies as git submodules.";
+  static requiresProject = true;
+  static args = {
+    args: [
+      { name: "url", required: true, description: "Git repository URL or gh@org/repo" }
+    ]
+  };
+  visited = /* @__PURE__ */ new Set();
+  async run(options) {
+    const projectRoot = this.projectRoot;
+    let { url } = options;
+    if (!url) {
+      this.error("Please specify a repository URL.");
+      return;
+    }
+    try {
+      await this.installModule(url);
+      this.info("Syncing workspace dependencies...");
+      await runCommand("npm install", projectRoot);
+      this.success("All modules installed successfully.");
+    } catch (e) {
+      this.error(`Failed to add module: ${e.message}`);
+    }
+  }
+  async installModule(url) {
+    const projectRoot = this.projectRoot;
+    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}...`);
+    const stagingDir = path.resolve(projectRoot, ".nexical", "cache", `staging-${Date.now()}-${Math.random().toString(36).substring(7)}`);
+    let moduleName = "";
+    let dependencies = [];
+    try {
+      await import_fs_extra.default.ensureDir(stagingDir);
+      await clone(cleanUrl, stagingDir, { depth: 1 });
+      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 import_fs_extra.default.pathExists(moduleYamlPath)) configPath = moduleYamlPath;
+      else if (await import_fs_extra.default.pathExists(moduleYmlPath)) configPath = moduleYmlPath;
+      else {
+        throw new Error(`No module.yaml found in ${cleanUrl}${subPath ? "//" + subPath : ""}`);
+      }
+      const configContent = await import_fs_extra.default.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 || [];
+      if (dependencies && !Array.isArray(dependencies)) {
+        dependencies = Object.keys(dependencies);
+      }
+    } catch (e) {
+      throw e;
+    } finally {
+      await import_fs_extra.default.remove(stagingDir);
+    }
+    const targetDir = path.join(projectRoot, "modules", moduleName);
+    const relativeTargetDir = path.relative(projectRoot, targetDir);
+    if (await import_fs_extra.default.pathExists(targetDir)) {
+      const existingRemote = await getRemoteUrl(targetDir);
+      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.`);
+    } else {
+      this.info(`Installing ${moduleName} to ${relativeTargetDir}...`);
+      await runCommand(`git submodule add ${cleanUrl} ${relativeTargetDir}`, projectRoot);
+    }
+    await this.addToConfig(moduleName);
+    if (dependencies.length > 0) {
+      this.info(`Resolving ${dependencies.length} dependencies for ${moduleName}...`);
+      for (const depUrl of dependencies) {
+        await this.installModule(depUrl);
+      }
+    }
+  }
+  async addToConfig(moduleName) {
+    const projectRoot = this.projectRoot;
+    const configPath = path.join(projectRoot, "nexical.yaml");
+    if (!await import_fs_extra.default.pathExists(configPath)) {
+      logger.warn("nexical.yaml not found, skipping module list update.");
+      return;
+    }
+    try {
+      const content = await import_fs_extra.default.readFile(configPath, "utf8");
+      let config = YAML.parse(content) || {};
+      if (!config.modules) config.modules = [];
+      if (!config.modules.includes(moduleName)) {
+        config.modules.push(moduleName);
+        await import_fs_extra.default.writeFile(configPath, YAML.stringify(config));
+        logger.debug(`Added ${moduleName} to nexical.yaml modules list.`);
+      }
+    } catch (e) {
+      logger.warn(`Failed to update nexical.yaml: ${e.message}`);
+    }
+  }
+};
+export {
+  ModuleAddCommand as default
+};
+//# sourceMappingURL=add.js.map

package/dist/src/commands/module/add.js.map

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

package/dist/src/commands/module/list.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '@nexical/cli-core';
+
+declare class ModuleListCommand extends BaseCommand {
+    static usage: string;
+    static description: string;
+    static requiresProject: boolean;
+    run(): Promise<void>;
+}
+
+export { ModuleListCommand as default };

package/dist/src/commands/module/list.js

@@ -0,0 +1,73 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+import {
+  require_lib
+} from "../../../chunk-LZ3YQWAR.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "../../../chunk-OYFWMYPG.js";
+
+// src/commands/module/list.ts
+init_esm_shims();
+var import_fs_extra = __toESM(require_lib(), 1);
+import { BaseCommand, logger } from "@nexical/cli-core";
+import path from "path";
+import YAML from "yaml";
+var ModuleListCommand = class extends BaseCommand {
+  static usage = "module list";
+  static description = "List installed modules.";
+  static requiresProject = true;
+  async run() {
+    const projectRoot = this.projectRoot;
+    const modulesDir = path.resolve(projectRoot, "modules");
+    logger.debug(`Scanning for modules in: ${modulesDir}`);
+    if (!await import_fs_extra.default.pathExists(modulesDir)) {
+      this.info("No modules installed (modules directory missing).");
+      return;
+    }
+    try {
+      const modules = await import_fs_extra.default.readdir(modulesDir);
+      const validModules = [];
+      for (const moduleName of modules) {
+        const modulePath = path.join(modulesDir, moduleName);
+        if ((await import_fs_extra.default.stat(modulePath)).isDirectory()) {
+          let version = "unknown";
+          let description = "";
+          const pkgJsonPath = path.join(modulePath, "package.json");
+          const moduleYamlPath = path.join(modulePath, "module.yaml");
+          const moduleYmlPath = path.join(modulePath, "module.yml");
+          let pkg = {};
+          let modConfig = {};
+          if (await import_fs_extra.default.pathExists(pkgJsonPath)) {
+            try {
+              pkg = await import_fs_extra.default.readJson(pkgJsonPath);
+            } catch (e) {
+            }
+          }
+          if (await import_fs_extra.default.pathExists(moduleYamlPath) || await import_fs_extra.default.pathExists(moduleYmlPath)) {
+            try {
+              const configPath = await import_fs_extra.default.pathExists(moduleYamlPath) ? moduleYamlPath : moduleYmlPath;
+              const content = await import_fs_extra.default.readFile(configPath, "utf8");
+              modConfig = YAML.parse(content) || {};
+            } catch (e) {
+            }
+          }
+          version = pkg.version || "unknown";
+          description = modConfig.description || pkg.description || "";
+          validModules.push({ name: moduleName, version, description });
+        }
+      }
+      if (validModules.length === 0) {
+        this.info("No modules installed.");
+      } else {
+        console.table(validModules);
+      }
+    } catch (error) {
+      this.error(`Failed to list modules: ${error.message}`);
+    }
+  }
+};
+export {
+  ModuleListCommand as default
+};
+//# sourceMappingURL=list.js.map

package/dist/src/commands/module/list.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/commands/module/list.ts"],"sourcesContent":["import { BaseCommand, logger } from '@nexical/cli-core';\nimport fs from 'fs-extra';\nimport path from 'path';\nimport YAML from 'yaml';\n\nexport default class ModuleListCommand extends BaseCommand {\n    static usage = 'module list';\n    static description = 'List installed modules.';\n    static requiresProject = true;\n\n    async run() {\n        const projectRoot = this.projectRoot as string;\n        const modulesDir = path.resolve(projectRoot, 'modules');\n        logger.debug(`Scanning for modules in: ${modulesDir}`);\n\n        if (!(await fs.pathExists(modulesDir))) {\n            this.info('No modules installed (modules directory missing).');\n            return;\n        }\n\n        try {\n            const modules = await fs.readdir(modulesDir);\n            const validModules: { name: string; version: string; description: string }[] = [];\n\n            for (const moduleName of modules) {\n                const modulePath = path.join(modulesDir, moduleName);\n                if ((await fs.stat(modulePath)).isDirectory()) {\n                    let version = 'unknown';\n                    let description = '';\n\n                    const pkgJsonPath = path.join(modulePath, 'package.json');\n                    const moduleYamlPath = path.join(modulePath, 'module.yaml');\n                    const moduleYmlPath = path.join(modulePath, 'module.yml');\n\n                    let pkg: any = {};\n                    let modConfig: any = {};\n\n                    if (await fs.pathExists(pkgJsonPath)) {\n                        try {\n                            pkg = await fs.readJson(pkgJsonPath);\n                        } catch (e) { /* ignore */ }\n                    }\n\n                    if (await fs.pathExists(moduleYamlPath) || await fs.pathExists(moduleYmlPath)) {\n                        try {\n                            const configPath = await fs.pathExists(moduleYamlPath) ? moduleYamlPath : moduleYmlPath;\n                            const content = await fs.readFile(configPath, 'utf8');\n                            modConfig = YAML.parse(content) || {};\n                        } catch (e) { /* ignore */ }\n                    }\n\n                    version = pkg.version || 'unknown';\n                    description = modConfig.description || pkg.description || '';\n                    // Optionally use display name from module.yaml if present, but strictly list is usually dir name.\n                    // Let's stick to dir name for \"name\" column, but description from module.yaml is good.\n                    validModules.push({ name: moduleName, version, description });\n                }\n            }\n\n            if (validModules.length === 0) {\n                this.info('No modules installed.');\n            } else {\n                console.table(validModules);\n            }\n        } catch (error: any) {\n            this.error(`Failed to list modules: ${error.message}`);\n        }\n    }\n}\n"],"mappings":";;;;;;;;;;AAAA;AACA,sBAAe;AADf,SAAS,aAAa,cAAc;AAEpC,OAAO,UAAU;AACjB,OAAO,UAAU;AAEjB,IAAqB,oBAArB,cAA+C,YAAY;AAAA,EACvD,OAAO,QAAQ;AAAA,EACf,OAAO,cAAc;AAAA,EACrB,OAAO,kBAAkB;AAAA,EAEzB,MAAM,MAAM;AACR,UAAM,cAAc,KAAK;AACzB,UAAM,aAAa,KAAK,QAAQ,aAAa,SAAS;AACtD,WAAO,MAAM,4BAA4B,UAAU,EAAE;AAErD,QAAI,CAAE,MAAM,gBAAAA,QAAG,WAAW,UAAU,GAAI;AACpC,WAAK,KAAK,mDAAmD;AAC7D;AAAA,IACJ;AAEA,QAAI;AACA,YAAM,UAAU,MAAM,gBAAAA,QAAG,QAAQ,UAAU;AAC3C,YAAM,eAAyE,CAAC;AAEhF,iBAAW,cAAc,SAAS;AAC9B,cAAM,aAAa,KAAK,KAAK,YAAY,UAAU;AACnD,aAAK,MAAM,gBAAAA,QAAG,KAAK,UAAU,GAAG,YAAY,GAAG;AAC3C,cAAI,UAAU;AACd,cAAI,cAAc;AAElB,gBAAM,cAAc,KAAK,KAAK,YAAY,cAAc;AACxD,gBAAM,iBAAiB,KAAK,KAAK,YAAY,aAAa;AAC1D,gBAAM,gBAAgB,KAAK,KAAK,YAAY,YAAY;AAExD,cAAI,MAAW,CAAC;AAChB,cAAI,YAAiB,CAAC;AAEtB,cAAI,MAAM,gBAAAA,QAAG,WAAW,WAAW,GAAG;AAClC,gBAAI;AACA,oBAAM,MAAM,gBAAAA,QAAG,SAAS,WAAW;AAAA,YACvC,SAAS,GAAG;AAAA,YAAe;AAAA,UAC/B;AAEA,cAAI,MAAM,gBAAAA,QAAG,WAAW,cAAc,KAAK,MAAM,gBAAAA,QAAG,WAAW,aAAa,GAAG;AAC3E,gBAAI;AACA,oBAAM,aAAa,MAAM,gBAAAA,QAAG,WAAW,cAAc,IAAI,iBAAiB;AAC1E,oBAAM,UAAU,MAAM,gBAAAA,QAAG,SAAS,YAAY,MAAM;AACpD,0BAAY,KAAK,MAAM,OAAO,KAAK,CAAC;AAAA,YACxC,SAAS,GAAG;AAAA,YAAe;AAAA,UAC/B;AAEA,oBAAU,IAAI,WAAW;AACzB,wBAAc,UAAU,eAAe,IAAI,eAAe;AAG1D,uBAAa,KAAK,EAAE,MAAM,YAAY,SAAS,YAAY,CAAC;AAAA,QAChE;AAAA,MACJ;AAEA,UAAI,aAAa,WAAW,GAAG;AAC3B,aAAK,KAAK,uBAAuB;AAAA,MACrC,OAAO;AACH,gBAAQ,MAAM,YAAY;AAAA,MAC9B;AAAA,IACJ,SAAS,OAAY;AACjB,WAAK,MAAM,2BAA2B,MAAM,OAAO,EAAE;AAAA,IACzD;AAAA,EACJ;AACJ;","names":["fs"]}

package/dist/src/commands/module/remove.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand, CommandDefinition } from '@nexical/cli-core';
+
+declare class ModuleRemoveCommand extends BaseCommand {
+    static usage: string;
+    static description: string;
+    static requiresProject: boolean;
+    static args: CommandDefinition;
+    run(options: any): Promise<void>;
+    private removeFromConfig;
+}
+
+export { ModuleRemoveCommand as default };

package/dist/src/commands/module/remove.js

@@ -0,0 +1,71 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+import {
+  require_lib
+} from "../../../chunk-LZ3YQWAR.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "../../../chunk-OYFWMYPG.js";
+
+// src/commands/module/remove.ts
+init_esm_shims();
+var import_fs_extra = __toESM(require_lib(), 1);
+import { BaseCommand, logger, runCommand } from "@nexical/cli-core";
+import path from "path";
+import YAML from "yaml";
+var ModuleRemoveCommand = class extends BaseCommand {
+  static usage = "module remove <name>";
+  static description = "Remove an installed module.";
+  static requiresProject = true;
+  static args = {
+    args: [
+      { name: "name", required: true, description: "Name of the module to remove" }
+    ]
+  };
+  async run(options) {
+    const projectRoot = this.projectRoot;
+    let { name } = options;
+    const relativePath = `modules/${name}`;
+    const fullPath = path.resolve(projectRoot, relativePath);
+    logger.debug("Removing module at:", fullPath);
+    if (!await import_fs_extra.default.pathExists(fullPath)) {
+      this.error(`Module ${name} not found at ${relativePath}.`);
+      return;
+    }
+    this.info(`Removing module ${name}...`);
+    try {
+      await runCommand(`git submodule deinit -f ${relativePath}`, projectRoot);
+      await runCommand(`git rm -f ${relativePath}`, projectRoot);
+      const gitModulesDir = path.resolve(projectRoot, ".git", "modules", "modules", name);
+      if (await import_fs_extra.default.pathExists(gitModulesDir)) {
+        await import_fs_extra.default.remove(gitModulesDir);
+      }
+      this.info("Syncing workspace dependencies...");
+      await runCommand("npm install", projectRoot);
+      await this.removeFromConfig(name);
+      this.success(`Module ${name} removed successfully.`);
+    } catch (e) {
+      this.error(`Failed to remove module: ${e.message}`);
+    }
+  }
+  async removeFromConfig(moduleName) {
+    const projectRoot = this.projectRoot;
+    const configPath = path.join(projectRoot, "nexical.yaml");
+    if (!await import_fs_extra.default.pathExists(configPath)) return;
+    try {
+      const content = await import_fs_extra.default.readFile(configPath, "utf8");
+      let config = YAML.parse(content) || {};
+      if (config.modules && config.modules.includes(moduleName)) {
+        config.modules = config.modules.filter((m) => m !== moduleName);
+        await import_fs_extra.default.writeFile(configPath, YAML.stringify(config));
+        logger.debug(`Removed ${moduleName} from nexical.yaml modules list.`);
+      }
+    } catch (e) {
+      logger.warn(`Failed to update nexical.yaml: ${e.message}`);
+    }
+  }
+};
+export {
+  ModuleRemoveCommand as default
+};
+//# sourceMappingURL=remove.js.map

package/dist/src/commands/module/remove.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/commands/module/remove.ts"],"sourcesContent":["import { type CommandDefinition, BaseCommand, logger, runCommand } from '@nexical/cli-core';\nimport fs from 'fs-extra';\nimport path from 'path';\nimport YAML from 'yaml';\n\nexport default class ModuleRemoveCommand extends BaseCommand {\n    static usage = 'module remove <name>';\n    static description = 'Remove an installed module.';\n    static requiresProject = true;\n\n    static args: CommandDefinition = {\n        args: [\n            { name: 'name', required: true, description: 'Name of the module to remove' }\n        ]\n    };\n\n    async run(options: any) {\n        const projectRoot = this.projectRoot as string;\n        let { name } = options;\n\n        const relativePath = `modules/${name}`;\n        const fullPath = path.resolve(projectRoot, relativePath);\n\n        logger.debug('Removing module at:', fullPath);\n\n        if (!(await fs.pathExists(fullPath))) {\n            this.error(`Module ${name} not found at ${relativePath}.`);\n            return;\n        }\n\n        this.info(`Removing module ${name}...`);\n\n        try {\n            await runCommand(`git submodule deinit -f ${relativePath}`, projectRoot);\n            await runCommand(`git rm -f ${relativePath}`, projectRoot);\n\n            // Clean up .git/modules\n            const gitModulesDir = path.resolve(projectRoot, '.git', 'modules', 'modules', name);\n            if (await fs.pathExists(gitModulesDir)) {\n                await fs.remove(gitModulesDir);\n            }\n\n            this.info('Syncing workspace dependencies...');\n            await runCommand('npm install', projectRoot);\n\n\n            await this.removeFromConfig(name);\n\n            this.success(`Module ${name} removed successfully.`);\n        } catch (e: any) {\n            this.error(`Failed to remove module: ${e.message}`);\n        }\n    }\n\n    private async removeFromConfig(moduleName: string) {\n        const projectRoot = this.projectRoot as string;\n        const configPath = path.join(projectRoot, 'nexical.yaml');\n\n        if (!await fs.pathExists(configPath)) return;\n\n        try {\n            const content = await fs.readFile(configPath, 'utf8');\n            let config = YAML.parse(content) || {};\n\n            if (config.modules && config.modules.includes(moduleName)) {\n                config.modules = config.modules.filter((m: string) => m !== moduleName);\n                await fs.writeFile(configPath, YAML.stringify(config));\n                logger.debug(`Removed ${moduleName} from nexical.yaml modules list.`);\n            }\n        } catch (e: any) {\n            logger.warn(`Failed to update nexical.yaml: ${e.message}`);\n        }\n    }\n}\n"],"mappings":";;;;;;;;;;AAAA;AACA,sBAAe;AADf,SAAiC,aAAa,QAAQ,kBAAkB;AAExE,OAAO,UAAU;AACjB,OAAO,UAAU;AAEjB,IAAqB,sBAArB,cAAiD,YAAY;AAAA,EACzD,OAAO,QAAQ;AAAA,EACf,OAAO,cAAc;AAAA,EACrB,OAAO,kBAAkB;AAAA,EAEzB,OAAO,OAA0B;AAAA,IAC7B,MAAM;AAAA,MACF,EAAE,MAAM,QAAQ,UAAU,MAAM,aAAa,+BAA+B;AAAA,IAChF;AAAA,EACJ;AAAA,EAEA,MAAM,IAAI,SAAc;AACpB,UAAM,cAAc,KAAK;AACzB,QAAI,EAAE,KAAK,IAAI;AAEf,UAAM,eAAe,WAAW,IAAI;AACpC,UAAM,WAAW,KAAK,QAAQ,aAAa,YAAY;AAEvD,WAAO,MAAM,uBAAuB,QAAQ;AAE5C,QAAI,CAAE,MAAM,gBAAAA,QAAG,WAAW,QAAQ,GAAI;AAClC,WAAK,MAAM,UAAU,IAAI,iBAAiB,YAAY,GAAG;AACzD;AAAA,IACJ;AAEA,SAAK,KAAK,mBAAmB,IAAI,KAAK;AAEtC,QAAI;AACA,YAAM,WAAW,2BAA2B,YAAY,IAAI,WAAW;AACvE,YAAM,WAAW,aAAa,YAAY,IAAI,WAAW;AAGzD,YAAM,gBAAgB,KAAK,QAAQ,aAAa,QAAQ,WAAW,WAAW,IAAI;AAClF,UAAI,MAAM,gBAAAA,QAAG,WAAW,aAAa,GAAG;AACpC,cAAM,gBAAAA,QAAG,OAAO,aAAa;AAAA,MACjC;AAEA,WAAK,KAAK,mCAAmC;AAC7C,YAAM,WAAW,eAAe,WAAW;AAG3C,YAAM,KAAK,iBAAiB,IAAI;AAEhC,WAAK,QAAQ,UAAU,IAAI,wBAAwB;AAAA,IACvD,SAAS,GAAQ;AACb,WAAK,MAAM,4BAA4B,EAAE,OAAO,EAAE;AAAA,IACtD;AAAA,EACJ;AAAA,EAEA,MAAc,iBAAiB,YAAoB;AAC/C,UAAM,cAAc,KAAK;AACzB,UAAM,aAAa,KAAK,KAAK,aAAa,cAAc;AAExD,QAAI,CAAC,MAAM,gBAAAA,QAAG,WAAW,UAAU,EAAG;AAEtC,QAAI;AACA,YAAM,UAAU,MAAM,gBAAAA,QAAG,SAAS,YAAY,MAAM;AACpD,UAAI,SAAS,KAAK,MAAM,OAAO,KAAK,CAAC;AAErC,UAAI,OAAO,WAAW,OAAO,QAAQ,SAAS,UAAU,GAAG;AACvD,eAAO,UAAU,OAAO,QAAQ,OAAO,CAAC,MAAc,MAAM,UAAU;AACtE,cAAM,gBAAAA,QAAG,UAAU,YAAY,KAAK,UAAU,MAAM,CAAC;AACrD,eAAO,MAAM,WAAW,UAAU,kCAAkC;AAAA,MACxE;AAAA,IACJ,SAAS,GAAQ;AACb,aAAO,KAAK,kCAAkC,EAAE,OAAO,EAAE;AAAA,IAC7D;AAAA,EACJ;AACJ;","names":["fs"]}

package/dist/src/commands/module/update.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand, CommandDefinition } from '@nexical/cli-core';
+
+declare class ModuleUpdateCommand extends BaseCommand {
+    static usage: string;
+    static description: string;
+    static requiresProject: boolean;
+    static args: CommandDefinition;
+    run(options: any): Promise<void>;
+}
+
+export { ModuleUpdateCommand as default };

package/dist/src/commands/module/update.js

@@ -0,0 +1,52 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+import {
+  require_lib
+} from "../../../chunk-LZ3YQWAR.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "../../../chunk-OYFWMYPG.js";
+
+// src/commands/module/update.ts
+init_esm_shims();
+var import_fs_extra = __toESM(require_lib(), 1);
+import { BaseCommand, logger, runCommand } from "@nexical/cli-core";
+import path from "path";
+var ModuleUpdateCommand = class extends BaseCommand {
+  static usage = "module update [name]";
+  static description = "Update a specific module or all modules.";
+  static requiresProject = true;
+  static args = {
+    args: [
+      { name: "name", required: false, description: "Name of the module to update" }
+    ]
+  };
+  async run(options) {
+    const projectRoot = this.projectRoot;
+    let { name } = options;
+    this.info(name ? `Updating module ${name}...` : "Updating all modules...");
+    logger.debug("Update context:", { name, projectRoot });
+    try {
+      if (name) {
+        const relativePath = `modules/${name}`;
+        const fullPath = path.resolve(projectRoot, relativePath);
+        if (!await import_fs_extra.default.pathExists(fullPath)) {
+          this.error(`Module ${name} not found.`);
+          return;
+        }
+        await runCommand(`git submodule update --remote --merge ${relativePath}`, projectRoot);
+      } else {
+        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) {
+      this.error(`Failed to update modules: ${e.message}`);
+    }
+  }
+};
+export {
+  ModuleUpdateCommand as default
+};
+//# sourceMappingURL=update.js.map