@nexical/cli 0.11.0 → 0.11.1

package/.github/workflows/deploy.yml

@@ -31,4 +31,4 @@ jobs:
       - name: Publish to NPM
         run: npm publish --access public
         env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

package/.prettierignore

@@ -0,0 +1,8 @@
+dist/
+coverage/
+node_modules/
+.astro/
+.next/
+pnpm-lock.yaml
+package-lock.json
+yarn.lock

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "trailingComma": "all",
+  "printWidth": 100
+}

package/GEMINI.md

@@ -5,6 +5,7 @@ This guide details how to build command libraries and CLIs using the `@nexical/c
 ## Overview
 
 The project is configured to use `@nexical/cli-core` as its CLI framework. usage entails:
+
 1.  **Entry Point**: `index.ts` initializes the `CLI` instance.
 2.  **Command Discovery**: The CLI automatically scans `src/commands` for command files.
 3.  **Command Implementation**: Commands are TypeScript classes extending `BaseCommand`.
@@ -13,11 +14,11 @@ The project is configured to use `@nexical/cli-core` as its CLI framework. usage
 
 Commands are defined in `src/commands`. The file structure directly maps to the command hierarchy.
 
-| File Path | Command | Description |
-| :--- | :--- | :--- |
-| `src/commands/init.ts` | `app init` | Root level command |
-| `src/commands/user/create.ts` | `app user create` | Subcommand |
-| `src/commands/user/index.ts` | `app user` | Parent command handler (optional) |
+| File Path                     | Command           | Description                       |
+| :---------------------------- | :---------------- | :-------------------------------- |
+| `src/commands/init.ts`        | `app init`        | Root level command                |
+| `src/commands/user/create.ts` | `app user create` | Subcommand                        |
+| `src/commands/user/index.ts`  | `app user`        | Parent command handler (optional) |
 
 > **Note**: The CLI name (`app`) is configured in `index.ts`.
 
@@ -44,6 +45,7 @@ export default class HelloCommand extends BaseCommand {
 ```
 
 **Run it:**
+
 ```bash
 npm run cli hello
 ```
@@ -64,33 +66,33 @@ export default class GreetCommand extends BaseCommand {
       {
         name: 'name',
         description: 'Name of the user',
-        required: true
-      }
+        required: true,
+      },
     ],
     // Options (Flags)
     options: [
       {
         name: '--loud',
         description: 'Print in uppercase',
-        default: false
+        default: false,
       },
       {
         name: '-c, --count <n>',
         description: 'Number of times to greet',
-        default: 1
-      }
-    ]
+        default: 1,
+      },
+    ],
   };
 
   async run(options: any) {
     // 'name' is mapped from args
     // 'loud' and 'count' are mapped from options
     const { name, loud, count } = options;
-    
+
     let message = `Hello, ${name}`;
     if (loud) message = message.toUpperCase();
 
-    for(let i=0; i < count; i++) {
+    for (let i = 0; i < count; i++) {
       this.info(message);
     }
   }
@@ -98,6 +100,7 @@ export default class GreetCommand extends BaseCommand {
 ```
 
 **Run it:**
+
 ```bash
 npm run cli greet Adrian --loud --count 3
 ```
@@ -111,7 +114,7 @@ export default class InteractiveCommand extends BaseCommand {
   async run() {
     // Simple confirmation or input
     const name = await this.prompt('What is your name?');
-    
+
     this.success(`Nice to meet you, ${name}`);
   }
 }
@@ -134,8 +137,8 @@ To create grouped commands (e.g., `user create`, `user list`), use directories.
 
 1.  **Create Directory**: `src/commands/user/`
 2.  **Add Commands**:
-    *   `src/commands/user/create.ts` -> `app user create`
-    *   `src/commands/user/list.ts` -> `app user list`
+    - `src/commands/user/create.ts` -> `app user create`
+    - `src/commands/user/list.ts` -> `app user list`
 
 ### Index Commands (Container Commands)
 
@@ -163,22 +166,25 @@ export default class UserCommand extends BaseCommand {
 All commands inherit from `BaseCommand`.
 
 **Properties:**
-*   `cli`: Access to the main `CLI` instance.
-*   `projectRoot`: Path to the project root (if detected).
-*   `config`: Loaded configuration from `{cliName}.yml`.
-*   `globalOptions`: Global flags passed to the CLI (e.g., `--debug`).
+
+- `cli`: Access to the main `CLI` instance.
+- `projectRoot`: Path to the project root (if detected).
+- `config`: Loaded configuration from `{cliName}.yml`.
+- `globalOptions`: Global flags passed to the CLI (e.g., `--debug`).
 
 **Methods:**
-*   `init()`: Called before `run()`. Useful for setup.
-*   `run(options)`: Abstract method. Must be implemented.
-*   `prompt(message)`: Async, returns string.
+
+- `init()`: Called before `run()`. Useful for setup.
+- `run(options)`: Abstract method. Must be implemented.
+- `prompt(message)`: Async, returns string.
 
 **Static Properties:**
-*   `description`: String. Shown in help.
-*   `args`: Object. Defines arguments and options.
-    *   `args`: Array of `{ name, description, required, default }`.
-    *   `options`: Array of `{ name, description, default }`.
-*   `requiresProject`: Boolean. If true, command fails if not run inside a project with a config file.
+
+- `description`: String. Shown in help.
+- `args`: Object. Defines arguments and options.
+  - `args`: Array of `{ name, description, required, default }`.
+  - `options`: Array of `{ name, description, default }`.
+- `requiresProject`: Boolean. If true, command fails if not run inside a project with a config file.
 
 ## Best Practices
 
@@ -189,5 +195,5 @@ All commands inherit from `BaseCommand`.
 
 ## Troubleshooting
 
-*   **Command not found**: Ensure the file exports a class leveraging `export default` and extends `BaseCommand`.
-*   **Changes not reflected**: If using `tsup`, ensure you are building or running in dev mode (`npm run dev`). For `npm run cli` using `ts-node` (via `cli.ts` or similar), changes should be instant.
+- **Command not found**: Ensure the file exports a class leveraging `export default` and extends `BaseCommand`.
+- **Changes not reflected**: If using `tsup`, ensure you are building or running in dev mode (`npm run dev`). For `npm run cli` using `ts-node` (via `cli.ts` or similar), changes should be instant.

package/README.md

@@ -11,9 +11,9 @@ This project serves as the primary entry point for managing Nexical projects, ha
 - [Getting Started](#getting-started)
 - [Project Structure](#project-structure)
 - [Development Workflow](#development-workflow)
-    - [Prerequisites](#prerequisites)
-    - [Setup](#setup)
-    - [Running Tests](#running-tests)
+  - [Prerequisites](#prerequisites)
+  - [Setup](#setup)
+  - [Running Tests](#running-tests)
 - [Adding New Commands](#adding-new-commands)
 - [Contributing](#contributing)
 - [License](#license)
@@ -23,6 +23,7 @@ This project serves as the primary entry point for managing Nexical projects, ha
 ## Purpose
 
 The Nexical CLI allows developers to:
+
 1.  **Initialize** new Nexical projects with best practices built-in.
 2.  **Manage** project configuration and dependencies.
 3.  **Extend** the framework functionality through modular commands.
@@ -34,27 +35,30 @@ It acts as a unification layer, bringing together various tools and configuratio
 This CLI is built with **TypeScript** and follows a **Class-Based Command Pattern** to ensure type safety and maintainability.
 
 ### Key Technologies
-*   **[CAC (Command And Conquer)](https://github.com/cacjs/cac)**: A lightweight, robust framework for building CLIs. It handles argument parsing, help generation, and command registration.
-*   **[Consola](https://github.com/unjs/consola)**: Elegant console logging with fallback and structured output capabilities.
-*   **[Lilconfig](https://github.com/antonk52/lilconfig)**: Configuration loading (searching for `nexical.yml`, `nexical.yaml`) akin to `cosmiconfig` but lighter.
-*   **Vitest**: A blazing fast unit test framework powered by Vite.
+
+- **[CAC (Command And Conquer)](https://github.com/cacjs/cac)**: A lightweight, robust framework for building CLIs. It handles argument parsing, help generation, and command registration.
+- **[Consola](https://github.com/unjs/consola)**: Elegant console logging with fallback and structured output capabilities.
+- **[Lilconfig](https://github.com/antonk52/lilconfig)**: Configuration loading (searching for `nexical.yml`, `nexical.yaml`) akin to `cosmiconfig` but lighter.
+- **Vitest**: A blazing fast unit test framework powered by Vite.
 
 ### Core Components
+
 1.  **`CLI` Class** (`src/core/CLI.ts`): The orchestrator. It initializes the CAC instance, discovers commands using the `CommandLoader`, registers them, and handles the execution lifecycle.
 2.  **`CommandLoader`** (`src/core/CommandLoader.ts`): Responsible for dynamically discovering and importing command files from the filesystem. It supports:
-    *   Recursive directory scanning.
-    *   Nested commands (e.g., `module/add.ts` -> `module add`).
-    *   Index files as parent commands (e.g., `module/index.ts` -> `module`).
+    - Recursive directory scanning.
+    - Nested commands (e.g., `module/add.ts` -> `module add`).
+    - Index files as parent commands (e.g., `module/index.ts` -> `module`).
 3.  **`BaseCommand`** (`src/core/BaseCommand.ts`): The abstract base class that all commands MUST extend. It provides:
-    *   Standardized `init()` and `run()` lifecycle methods.
-    *   Built-in access to global options (like `--root-dir`).
-    *   Helper methods for logging (`this.log`, `this.warn`, `this.error`).
-    *   Project root detection (`this.projectRoot`).
+    - Standardized `init()` and `run()` lifecycle methods.
+    - Built-in access to global options (like `--root-dir`).
+    - Helper methods for logging (`this.log`, `this.warn`, `this.error`).
+    - Project root detection (`this.projectRoot`).
 
 ### Design Goals
-*   **Zero-Config Defaults**: It should work out of the box but allow rich configuration via `nexical.yaml`.
-*   **Extensibility**: Adding a command should be as simple as adding a file.
-*   **Testability**: Every component is designed to be unit-testable, with dependency injection where appropriate (e.g., `CommandLoader` importer).
+
+- **Zero-Config Defaults**: It should work out of the box but allow rich configuration via `nexical.yaml`.
+- **Extensibility**: Adding a command should be as simple as adding a file.
+- **Testability**: Every component is designed to be unit-testable, with dependency injection where appropriate (e.g., `CommandLoader` importer).
 
 ---
 
@@ -94,19 +98,23 @@ npx nexical help module add
 Initializes a new Nexical project by cloning a starter repository, setting up dependencies, and preparing a fresh git history.
 
 **Usage:**
+
 ```bash
 npx nexical init <directory> [options]
 ```
 
 **Arguments:**
+
 - `directory` (Required): The directory to initialize the project in. If the directory does not exist, it will be created. If it does exist, it must be empty.
 
 **Options:**
+
 - `--repo <url>` (Default: `https://github.com/nexical/app-core`): The URL of the starter repository to clone.
-    - Supports standard Git URLs (e.g., `https://github.com/user/repo.git`).
-    - Supports GitHub short syntax `gh@owner/repo` (e.g., `gh@nexical/app-core`).
+  - Supports standard Git URLs (e.g., `https://github.com/user/repo.git`).
+  - Supports GitHub short syntax `gh@owner/repo` (e.g., `gh@nexical/app-core`).
 
 **What it does:**
+
 1.  **Clones** the specified starter repository (recursively, including submodules) into the target directory.
 2.  **Updates** all submodules to their latest `main` branch.
 3.  **Installs** dependencies using `npm install`.
@@ -118,6 +126,7 @@ npx nexical init <directory> [options]
     - Removes the `origin` remote to prevent accidental pushes to the starter repo.
 
 **Output:**
+
 - A ready-to-use Nexical project in the specified directory, with fresh git history and installed dependencies.
 
 ---
@@ -127,13 +136,12 @@ npx nexical init <directory> [options]
 Starts the development server in ephemeral mode. It constructs a temporary build environment in `site` and runs the Astro dev server with Hot Module Replacement (HMR).
 
 **Usage:**
+
 ```bash
 npx nexical dev
 ```
 
-**What it does:**
-2.  **Starts** the Astro development server (accessible at `http://localhost:4321` by default).
-3.  **Watches** for changes in your project and updates the ephemeral build automatically.
+**What it does:** 2. **Starts** the Astro development server (accessible at `http://localhost:4321` by default). 3. **Watches** for changes in your project and updates the ephemeral build automatically.
 
 ---
 
@@ -142,16 +150,19 @@ npx nexical dev
 Compiles the project for production. It assembles the final site structure in `site` and generates static assets.
 
 **Usage:**
+
 ```bash
 npx nexical build
 ```
 
 **What it does:**
+
 1.  **Cleans** the `site` directory to ensure a fresh build.
 2.  **Copies** all necessary source files (`src/`, `modules`, `src/content`, `public`) into `site`.
 3.  **Runs** `astro build` to generate the production output in `site/dist`.
 
 **Output:**
+
 - A production-ready static site in `site/dist`.
 
 ---
@@ -161,14 +172,17 @@ npx nexical build
 Previews the locally built production site. This is useful for verifying the output of `nexical build` before deploying.
 
 **Usage:**
+
 ```bash
 npx nexical preview
 ```
 
 **Prerequisites:**
+
 - You must run `nexical build` first.
 
 **What it does:**
+
 - Starts a local web server serving the static files from `site/dist`.
 
 ---
@@ -178,11 +192,13 @@ npx nexical preview
 Removes generated build artifacts and temporary directories to ensure a clean state.
 
 **Usage:**
+
 ```bash
 npx nexical clean
 ```
 
 **What it does:**
+
 - Deletes `site`, `dist`, and `node_modules/.vite`.
 
 ---
@@ -192,17 +208,20 @@ npx nexical clean
 Executes a script within the Nexical environment context. This handles path resolution and environment variable setup for you.
 
 **Usage:**
+
 ```bash
 npx nexical run <script> [args...]
 ```
 
 **Arguments:**
+
 - `script` (Required): The name of the script to run.
-    - Can be a standard `package.json` script (e.g., `test`).
-    - Can be a module-specific script using `module:script` syntax (e.g., `blog:sync`).
+  - Can be a standard `package.json` script (e.g., `test`).
+  - Can be a module-specific script using `module:script` syntax (e.g., `blog:sync`).
 - `args` (Optional): Additional arguments to pass to the script.
 
 **Examples:**
+
 ```bash
 # Run a core project script
 npx nexical run test
@@ -222,16 +241,19 @@ Manages the modular architecture of your Nexical project. Allows you to add, rem
 Adds a new module as a Git submodule.
 
 **Usage:**
+
 ```bash
 npx nexical module add <url> [name]
 ```
 
 **Arguments:**
+
 - `url` (Required): The Git repository URL of the module.
-    - Supports `gh@owner/repo` shorthand.
+  - Supports `gh@owner/repo` shorthand.
 - `name` (Optional): The folder name for the module. Defaults to the repository name.
 
 **What it does:**
+
 1.  Adds the repository as a git submodule in `src/modules/<name>`.
 2.  Installs any new dependencies via `npm install`.
 
@@ -240,11 +262,13 @@ npx nexical module add <url> [name]
 Lists all installed modules in the project.
 
 **Usage:**
+
 ```bash
 npx nexical module list
 ```
 
 **Output:**
+
 - A table showing the name, version, and description of each installed module found in `src/modules`.
 
 ##### `module update`
@@ -252,14 +276,17 @@ npx nexical module list
 Updates one or all modules to their latest remote commit.
 
 **Usage:**
+
 ```bash
 npx nexical module update [name]
 ```
 
 **Arguments:**
+
 - `name` (Optional): The specific module to update. If omitted, all modules are updated.
 
 **What it does:**
+
 1.  Runs `git submodule update --remote --merge` for the target(s).
 2.  Re-installs dependencies to ensure `package-lock.json` is consistent.
 
@@ -268,14 +295,17 @@ npx nexical module update [name]
 Removes an installed module and cleans up references.
 
 **Usage:**
+
 ```bash
 npx nexical module remove <name>
 ```
 
 **Arguments:**
+
 - `name` (Required): The name of the module to remove.
 
 **What it does:**
+
 1.  De-initializes the git submodule.
 2.  Removes the module directory from `src/modules`.
 3.  Cleans up internal git metadata (`.git/modules`).
@@ -298,22 +328,24 @@ graph TD
     utils-->logger.ts
 ```
 
-*   **`src/commands/`**: Contains the implementations of individual CLI commands. File names correspond to command names.
-*   **`src/core/`**: The framework logic (Command loading, Base class, CLI orchestration).
-*   **`src/utils/`**: Shared utilities (Logging, Configuration parsing).
-*   **`test/unit/`**: Co-located unit tests. Mirrors the `src` structure.
+- **`src/commands/`**: Contains the implementations of individual CLI commands. File names correspond to command names.
+- **`src/core/`**: The framework logic (Command loading, Base class, CLI orchestration).
+- **`src/utils/`**: Shared utilities (Logging, Configuration parsing).
+- **`test/unit/`**: Co-located unit tests. Mirrors the `src` structure.
 
 ---
 
 ## Development Workflow
 
 ### Prerequisites
-*   Node.js (v18+ recommended)
-*   NPM
+
+- Node.js (v18+ recommended)
+- NPM
 
 ### Setup
 
 1.  **Install Dependencies**:
+
     ```bash
     npm install
     ```
@@ -347,43 +379,40 @@ To create a new command, add a TypeScript file to `src/commands/`.
 import { BaseCommand } from '../core/BaseCommand.js';
 
 export default class HelloCommand extends BaseCommand {
-    // 1. Define command metadata
-    static description = 'Say hello to the world';
-    
-    static args = {
-        args: [
-            { name: 'name', required: false, description: 'User name' }
-        ],
-        options: [
-            { name: '--shout', description: 'Say it loud', default: false }
-        ]
-    };
-
-    // 2. Implement the run method
-    async run(options: any) {
-        const name = options.name || 'World';
-        
-        if (options.shout) {
-            this.success(`HELLO ${name.toUpperCase()}!`);
-        } else {
-            this.log(`Hello ${name}`);
-        }
+  // 1. Define command metadata
+  static description = 'Say hello to the world';
+
+  static args = {
+    args: [{ name: 'name', required: false, description: 'User name' }],
+    options: [{ name: '--shout', description: 'Say it loud', default: false }],
+  };
+
+  // 2. Implement the run method
+  async run(options: any) {
+    const name = options.name || 'World';
+
+    if (options.shout) {
+      this.success(`HELLO ${name.toUpperCase()}!`);
+    } else {
+      this.log(`Hello ${name}`);
     }
+  }
 }
 ```
 
 **Key Requirement**: The file MUST default export a class extending `BaseCommand`.
 
-*   **File Naming**:
-    *   `hello.ts` -> Command: `hello`
-    *   `users/create.ts` -> Command: `users create`
-    *   `users/index.ts` -> Command: `users` (Parent command)
+- **File Naming**:
+  - `hello.ts` -> Command: `hello`
+  - `users/create.ts` -> Command: `users create`
+  - `users/index.ts` -> Command: `users` (Parent command)
 
 ---
 
 ## Contributing
 
 Contributions are welcome! Please follow these steps:
+
 1.  Fork the repository.
 2.  Create a feature branch.
 3.  Add your changes and **ensure tests pass with 100% coverage**.

package/dist/chunk-AC4B3HPJ.js

@@ -0,0 +1,93 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-OYFWMYPG.js";
+
+// src/utils/discovery.ts
+init_esm_shims();
+import { logger } from "@nexical/cli-core";
+import path from "path";
+import fs from "fs";
+function discoverCommandDirectories(projectRoot) {
+  const directories = [];
+  const visited = /* @__PURE__ */ new Set();
+  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) => {
+    const resolved = path.resolve(dir);
+    if (!fs.existsSync(resolved)) {
+      logger.debug(`Command directory not found (skipping): ${resolved}`);
+      return;
+    }
+    if (visited.has(resolved)) return;
+    const srcPattern = path.join(path.sep, "src", "commands");
+    const distPattern = path.join(path.sep, "dist");
+    const isSrcDir = resolved.endsWith(srcPattern) && !resolved.includes(distPattern);
+    if (isSrcDir) {
+      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;
+      }
+      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);
+  };
+  const possibleCorePaths = [path.join(projectRoot, "src/commands")];
+  possibleCorePaths.forEach(addDir);
+  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;
+        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;
+            }
+          }
+        }
+        if (!foundDist) {
+          const srcPath = path.join(entryPath, "src/commands");
+          if (fs.existsSync(srcPath) && fs.statSync(srcPath).isDirectory()) {
+            addDir(srcPath);
+          }
+        }
+      }
+    } catch (e) {
+      logger.debug(`Error scanning root ${root}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  });
+  return directories;
+}
+
+export {
+  discoverCommandDirectories
+};
+//# sourceMappingURL=chunk-AC4B3HPJ.js.map

package/dist/chunk-AC4B3HPJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/discovery.ts"],"sourcesContent":["import { logger } from '@nexical/cli-core';\nimport path from 'node:path';\nimport fs from 'node:fs';\n\n/**\n * Discovers command directories to load into the CLI.\n *\n * Scans for:\n * 1. Core commands (projectRoot/src/commands)\n * 2. Module commands (projectRoot/src/modules/ * /src/commands)\n *\n * @param projectRoot - The root directory of the project\n * @returns Array of absolute paths to command directories\n */\nexport function discoverCommandDirectories(projectRoot: string): string[] {\n  const directories: string[] = [];\n  const visited = new Set<string>();\n\n  const isTsEnvironment =\n    process.argv[1]?.endsWith('.ts') ||\n    process.argv[1]?.endsWith('.mts') ||\n    process.execArgv.some(\n      (arg) => arg.includes('tsx') || arg.includes('ts-node') || arg.includes('vitest'),\n    ) ||\n    process.env.VITEST === 'true' ||\n    process.env.NODE_ENV === 'test';\n\n  const addDir = (dir: string) => {\n    const resolved = path.resolve(dir);\n    if (!fs.existsSync(resolved)) {\n      logger.debug(`Command directory not found (skipping): ${resolved}`);\n      return;\n    }\n\n    if (visited.has(resolved)) return;\n\n    // Detect if this is a source command directory\n    const srcPattern = path.join(path.sep, 'src', 'commands');\n    const distPattern = path.join(path.sep, 'dist');\n    const isSrcDir = resolved.endsWith(srcPattern) && !resolved.includes(distPattern);\n\n    // Strict check: if we are adding a 'src' directory...\n    if (isSrcDir) {\n      // 1. Check if an equivalent 'dist' exists in the same package\n      const distPath1 = resolved.replace(\n        srcPattern,\n        path.join(path.sep, 'dist', 'src', 'commands'),\n      );\n      const distPath2 = resolved.replace(srcPattern, path.join(path.sep, 'dist', 'commands'));\n\n      if (fs.existsSync(distPath1) || fs.existsSync(distPath2)) {\n        logger.debug(`Skipping src commands at ${resolved} because dist exists`);\n        return;\n      }\n\n      // 2. If no TS loader, skip src/commands entirely IF it's likely to contain .ts\n      if (!isTsEnvironment) {\n        logger.debug(`Skipping src commands at ${resolved}: no TS loader detected`);\n        return;\n      }\n    }\n\n    logger.debug(`Found command directory: ${resolved}`);\n    directories.push(resolved);\n    visited.add(resolved);\n  };\n\n  // 1. Core commands\n  const possibleCorePaths = [path.join(projectRoot, 'src/commands')];\n  possibleCorePaths.forEach(addDir);\n\n  // 2. Module & Package commands\n  const searchRoots = [\n    path.join(projectRoot, 'modules'),\n    path.join(projectRoot, 'src', 'modules'),\n    path.join(projectRoot, 'packages'),\n  ];\n\n  searchRoots.forEach((root) => {\n    if (!fs.existsSync(root)) return;\n    try {\n      const entries = fs.readdirSync(root);\n      for (const entry of entries) {\n        if (entry.startsWith('.')) continue;\n        const entryPath = path.join(root, entry);\n        if (!fs.statSync(entryPath).isDirectory()) continue;\n\n        // Preference: dist/src/commands > dist/commands > src/commands\n        const possiblePaths = [\n          path.join(entryPath, 'dist/src/commands'),\n          path.join(entryPath, 'dist/commands'),\n          path.join(entryPath, 'src/commands'),\n        ];\n\n        let foundDist = false;\n        for (const p of possiblePaths) {\n          if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {\n            if (p.includes(path.sep + 'dist' + path.sep)) {\n              addDir(p);\n              foundDist = true;\n              break; // Found a dist version, skip others for this entry\n            }\n          }\n        }\n\n        if (!foundDist) {\n          const srcPath = path.join(entryPath, 'src/commands');\n          if (fs.existsSync(srcPath) && fs.statSync(srcPath).isDirectory()) {\n            addDir(srcPath);\n          }\n        }\n      }\n    } catch (e: unknown) {\n      logger.debug(`Error scanning root ${root}: ${e instanceof Error ? e.message : String(e)}`);\n    }\n  });\n\n  return directories;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-JYASTIIW.js → chunk-PJIOCW2A.js}

@@ -39,4 +39,4 @@ function resolveGitUrl(url) {
 export {
   resolveGitUrl
 };
-//# sourceMappingURL=chunk-JYASTIIW.js.map
+//# sourceMappingURL=chunk-PJIOCW2A.js.map

package/dist/chunk-PJIOCW2A.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/url-resolver.ts"],"sourcesContent":["/**\n * Resolves a git URL from various shorthand formats.\n *\n * Supported formats:\n * - gh@org/repo -> https://github.com/org/repo.git\n * - gh@org/repo//path -> https://github.com/org/repo.git//path\n * - https://github.com/org/repo -> https://github.com/org/repo.git\n * - https://github.com/org/repo.git -> https://github.com/org/repo.git\n *\n * @param url The URL string to resolve\n * @returns The fully qualified git URL with .git extension\n */\nexport function resolveGitUrl(url: string): string {\n  if (!url) {\n    throw new Error('URL cannot be empty');\n  }\n\n  let resolved = url;\n\n  // Handle gh@ syntax\n  if (resolved.startsWith('gh@')) {\n    resolved = resolved.replace(/^gh@/, 'https://github.com/');\n  }\n\n  // Handle subpaths (split by //)\n  // We must be careful not to split the protocol (e.g. https://)\n  const protocolMatch = resolved.match(/^[a-z0-9]+:\\/\\//i);\n  let splitIndex = -1;\n\n  if (protocolMatch) {\n    splitIndex = resolved.indexOf('//', protocolMatch[0].length);\n  } else {\n    splitIndex = resolved.indexOf('//');\n  }\n\n  let repoUrl = resolved;\n  let subPath = '';\n\n  if (splitIndex !== -1) {\n    repoUrl = resolved.substring(0, splitIndex);\n    subPath = resolved.substring(splitIndex + 2);\n  }\n\n  // Ensure .git extension, but ONLY for remote URLs (not local paths)\n  const isLocal =\n    repoUrl.startsWith('/') ||\n    repoUrl.startsWith('./') ||\n    repoUrl.startsWith('../') ||\n    repoUrl.startsWith('file:') ||\n    repoUrl.startsWith('~');\n\n  if (!isLocal && !repoUrl.endsWith('.git')) {\n    repoUrl += '.git';\n  }\n\n  // Reconstruction\n  if (subPath) {\n    return `${repoUrl}//${subPath}`;\n  }\n\n  return repoUrl;\n}\n"],"mappings":";;;;;;AAAA;AAYO,SAAS,cAAc,KAAqB;AACjD,MAAI,CAAC,KAAK;AACR,UAAM,IAAI,MAAM,qBAAqB;AAAA,EACvC;AAEA,MAAI,WAAW;AAGf,MAAI,SAAS,WAAW,KAAK,GAAG;AAC9B,eAAW,SAAS,QAAQ,QAAQ,qBAAqB;AAAA,EAC3D;AAIA,QAAM,gBAAgB,SAAS,MAAM,kBAAkB;AACvD,MAAI,aAAa;AAEjB,MAAI,eAAe;AACjB,iBAAa,SAAS,QAAQ,MAAM,cAAc,CAAC,EAAE,MAAM;AAAA,EAC7D,OAAO;AACL,iBAAa,SAAS,QAAQ,IAAI;AAAA,EACpC;AAEA,MAAI,UAAU;AACd,MAAI,UAAU;AAEd,MAAI,eAAe,IAAI;AACrB,cAAU,SAAS,UAAU,GAAG,UAAU;AAC1C,cAAU,SAAS,UAAU,aAAa,CAAC;AAAA,EAC7C;AAGA,QAAM,UACJ,QAAQ,WAAW,GAAG,KACtB,QAAQ,WAAW,IAAI,KACvB,QAAQ,WAAW,KAAK,KACxB,QAAQ,WAAW,OAAO,KAC1B,QAAQ,WAAW,GAAG;AAExB,MAAI,CAAC,WAAW,CAAC,QAAQ,SAAS,MAAM,GAAG;AACzC,eAAW;AAAA,EACb;AAGA,MAAI,SAAS;AACX,WAAO,GAAG,OAAO,KAAK,OAAO;AAAA,EAC/B;AAEA,SAAO;AACT;","names":[]}