@nexical/cli-core 0.1.0 → 0.1.2

package/README.md

@@ -0,0 +1,195 @@
+# @nexical/cli-core
+
+The core framework for building powerful, extensible Command Line Interfaces (CLIs) within the Nexical ecosystem.
+
+This package provides the foundational architecture for specialized CLI toolsets, including command discovery, execution orchestration, and a class-based command pattern. It is designed to be **agnostic**, allowing it to be used as the backbone for other CLI tools that need a similar structure and extensibility.
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Usage](#usage)
+    - [Configuration](#configuration)
+    - [Directory Structure](#directory-structure)
+- [Creating Commands](#creating-commands)
+    - [The BaseCommand](#the-basecommand)
+    - [Defining Arguments & Options](#defining-arguments--options)
+    - [Command Discovery Rules](#command-discovery-rules)
+- [Architecture](#architecture)
+- [License](#license)
+
+---
+
+## Features
+
+*   **Class-Based Architecture**: Build commands as TypeScript classes with inheritance and lifecycle methods.
+*   **Dynamic Discovery**: Automatically recursively finds and registers commands from specified directories.
+*   **Type-Safe Definitions**: Declarative definition of arguments and options.
+*   **Built-in Help**: Automatic generation of help text for commands and subcommands.
+*   **Configuration Support**: Aware of project-level configuration (e.g., `{command_name}.yml`).
+*   **Robust Error Handling**: Standardized error reporting and debug modes.
+
+---
+
+## Installation
+
+This package is typically used as a dependency within a specific CLI implementation (like `@astrical/cli`).
+
+```bash
+npm install @nexical/cli-core
+```
+
+---
+
+## Usage
+
+To use the core framework, you need to instantiate the `CLI` class and start it. This is typically done in your CLI's entry point (e.g., `index.ts`).
+
+### Configuration
+
+The `CLI` class accepts a `CLIConfig` object to customize behavior:
+
+```typescript
+import { CLI } from '@nexical/cli-core';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const app = new CLI({
+    // 1. The name of your binary/command (displayed in help)
+    commandName: 'my-cli', 
+
+    // 2. Directories to recursively search for command files
+    searchDirectories: [
+        path.resolve(__dirname, 'commands'),
+        // You can add multiple directories, e.g., for plugins
+        path.resolve(process.cwd(), 'plugins/commands')
+    ]
+});
+
+app.start();
+```
+
+### Directory Structure
+
+A typical project using `@nexical/cli-core` looks like this:
+
+```
+my-cli/
+├── package.json
+├── src/
+│   ├── index.ts        <-- Entry point (initializes CLI)
+│   └── commands/       <-- Command files
+│       ├── init.ts
+│       ├── build.ts
+│       └── module/     <-- Subcommands
+│           ├── add.ts
+│           └── list.ts
+```
+
+---
+
+## Creating Commands
+
+The core framework itself only includes a **Help** command. All functional commands must be implemented by consuming libraries.
+
+### The BaseCommand
+
+All commands must extend the `BaseCommand` abstract class exported by the core.
+
+```typescript
+// src/commands/greet.ts
+import { BaseCommand } from '@nexical/cli-core';
+
+export default class GreetCommand extends BaseCommand {
+    // Description shown in help
+    static description = 'Greets the user';
+
+    // Implement the run method
+    async run(options: any) {
+        this.log('Hello from my-cli!');
+    }
+}
+```
+
+### Defining Arguments & Options
+
+You can define arguments and options using the static `args` property.
+
+```typescript
+export default class GreetCommand extends BaseCommand {
+    static description = 'Greets the user with a custom message';
+
+    static args = {
+        // Positional arguments
+        args: [
+            { 
+                name: 'name', 
+                required: false, 
+                description: 'Name to greet',
+                default: 'World'
+            }
+        ],
+        // Flags/Options
+        options: [
+            { 
+                name: '--shout', 
+                description: 'Print in uppercase', 
+                default: false 
+            },
+            {
+                name: '--count <n>',
+                description: 'Number of times to greet',
+                default: 1
+            }
+        ]
+    };
+
+    async run(options: any) {
+        // 'name' comes from args (mapped to options by name)
+        // 'shout' and 'count' come from options
+        const { name, shout, count } = options;
+        
+        const message = `Hello, ${name}!`;
+        const finalMessage = shout ? message.toUpperCase() : message;
+
+        for (let i = 0; i < count; i++) {
+            this.log(finalMessage);
+        }
+    }
+}
+```
+
+### Command Discovery Rules
+
+The `CommandLoader` uses the file structure to determine command names:
+
+*   **File Name = Command Name**: 
+    *   `commands/build.ts` -> `my-cli build`
+*   **Nested Directories = Subcommands**:
+    *   `commands/user/create.ts` -> `my-cli user create`
+*   **Index Files = Parent Command**:
+    *   `commands/user/index.ts` -> `my-cli user` (The handler for the root `user` command)
+    
+> **Note**: A file must default export a class extending `BaseCommand` to be registered.
+
+---
+
+## Architecture
+
+The core is built around three main components:
+
+1.  **`CLI`**: The main entry point. It wraps [CAC](https://github.com/cacjs/cac) to handle argument parsing and acts as the dependency injection container for commands.
+2.  **`CommandLoader`**: Scans the filesystem for command files. It handles importing typescript files and validating that they export a valid command class.
+3.  **`BaseCommand`**: Provides the interface for commands, including:
+    *   `init()`: Async initialization hook (pre-run).
+    *   `run()`: The main execution logic.
+    *   `this.projectRoot`: Automatically resolved path to the project root (if running in a project context).
+    *   Logging helpers (`this.success`, `this.warn`, `this.error`).
+
+---
+
+## License
+
+Apache-2.0

package/cli.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { CLI } from './src/CLI.js';
+
+import { logger } from './src/utils/logger.js';
+
+logger.debug('CLI ENTRY POINT HIT', process.argv);
+
+const app = new CLI();
+app.start();

package/dist/chunk-2HJDWSDA.js

@@ -0,0 +1,19 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+
+// src/utils/logger.ts
+import { consola, LogLevels } from "consola";
+var logger = consola.create({
+  defaults: {
+    tag: "CLI"
+  },
+  level: LogLevels.info
+});
+function setDebugMode(enabled) {
+  logger.level = enabled ? LogLevels.debug : LogLevels.info;
+}
+
+export {
+  logger,
+  setDebugMode
+};
+//# sourceMappingURL=chunk-2HJDWSDA.js.map

package/dist/chunk-2HJDWSDA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/logger.ts"],"sourcesContent":["import { consola, LogLevels } from 'consola';\n\nexport const logger = consola.create({\n    defaults: {\n        tag: 'CLI',\n    },\n    level: LogLevels.info\n});\n\nexport function setDebugMode(enabled: boolean) {\n    logger.level = enabled ? LogLevels.debug : LogLevels.info;\n}\n"],"mappings":";;;AAAA,SAAS,SAAS,iBAAiB;AAE5B,IAAM,SAAS,QAAQ,OAAO;AAAA,EACjC,UAAU;AAAA,IACN,KAAK;AAAA,EACT;AAAA,EACA,OAAO,UAAU;AACrB,CAAC;AAEM,SAAS,aAAa,SAAkB;AAC3C,SAAO,QAAQ,UAAU,UAAU,QAAQ,UAAU;AACzD;","names":[]}

package/dist/chunk-C4IL52NB.js

@@ -0,0 +1,2 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+//# sourceMappingURL=chunk-C4IL52NB.js.map

package/dist/chunk-C4IL52NB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-CKAS75E6.js

@@ -0,0 +1,67 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+import {
+  findProjectRoot,
+  loadConfig
+} from "./chunk-IIOHHU2E.js";
+import {
+  logger
+} from "./chunk-2HJDWSDA.js";
+
+// src/BaseCommand.ts
+import process from "process";
+var BaseCommand = class {
+  static usage = "";
+  static description = "";
+  static args = {};
+  // Configurable flags
+  static requiresProject = false;
+  projectRoot = null;
+  config = {};
+  globalOptions = {};
+  cli = null;
+  constructor(cli, globalOptions = {}) {
+    this.globalOptions = globalOptions;
+    this.cli = cli;
+  }
+  async init() {
+    if (this.globalOptions.rootDir) {
+      this.projectRoot = this.globalOptions.rootDir;
+    } else {
+      this.projectRoot = await findProjectRoot(this.cli.name, process.cwd());
+    }
+    const requiresProject = this.constructor.requiresProject;
+    if (requiresProject && !this.projectRoot) {
+      this.error("This command requires to be run within an app project (app.yml not found).", 1);
+      return;
+    }
+    if (this.projectRoot) {
+      this.config = await loadConfig(this.cli.name, this.projectRoot);
+    }
+  }
+  // Helpers
+  success(msg) {
+    logger.success(msg);
+  }
+  info(msg) {
+    logger.info(msg);
+  }
+  warn(msg) {
+    logger.warn(msg);
+  }
+  error(msg, code = 1) {
+    if (msg instanceof Error) {
+      logger.error(msg.message);
+      if (this.globalOptions.debug) {
+        logger.error(msg.stack);
+      }
+    } else {
+      logger.error(msg);
+    }
+    process.exit(code);
+  }
+};
+
+export {
+  BaseCommand
+};
+//# sourceMappingURL=chunk-CKAS75E6.js.map

package/dist/chunk-CKAS75E6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/BaseCommand.ts"],"sourcesContent":["import { logger } from './utils/logger.js';\nimport { CommandDefinition, CommandInterface } from './CommandInterface.js';\nimport { findProjectRoot, loadConfig } from './utils/config.js';\nimport process from 'node:process';\n\nexport abstract class BaseCommand implements CommandInterface {\n    static usage = '';\n    static description = '';\n    static args: CommandDefinition = {};\n\n    // Configurable flags\n    static requiresProject = false;\n\n    protected projectRoot: string | null = null;\n    protected config: any = {};\n    protected globalOptions: any = {};\n    protected cli: any = null;\n\n\n    constructor(cli: any, globalOptions: any = {}) {\n        this.globalOptions = globalOptions;\n        this.cli = cli;\n    }\n\n    async init() {\n        // 1. Root detection strategy\n        if (this.globalOptions.rootDir) {\n            this.projectRoot = this.globalOptions.rootDir;\n        } else {\n            this.projectRoot = await findProjectRoot(this.cli.name, process.cwd());\n        }\n\n        const requiresProject = (this.constructor as any).requiresProject;\n\n        if (requiresProject && !this.projectRoot) {\n            this.error('This command requires to be run within an app project (app.yml not found).', 1);\n            return; // TS doesn't know error exits\n        }\n\n        if (this.projectRoot) {\n            this.config = await loadConfig(this.cli.name, this.projectRoot);\n            // logger.debug(`Loaded config from ${this.projectRoot}`);\n        }\n    }\n\n    abstract run(options: any): Promise<void>;\n\n    // Helpers\n    success(msg: string) {\n        logger.success(msg);\n    }\n\n\n    info(msg: string) {\n        logger.info(msg);\n    }\n\n    warn(msg: string) {\n        logger.warn(msg);\n    }\n\n    error(msg: string | Error, code = 1) {\n        if (msg instanceof Error) {\n            logger.error(msg.message);\n            if (this.globalOptions.debug) {\n                logger.error(msg.stack);\n            }\n        } else {\n            logger.error(msg);\n        }\n        process.exit(code);\n    }\n}\n"],"mappings":";;;;;;;;;;AAGA,OAAO,aAAa;AAEb,IAAe,cAAf,MAAuD;AAAA,EAC1D,OAAO,QAAQ;AAAA,EACf,OAAO,cAAc;AAAA,EACrB,OAAO,OAA0B,CAAC;AAAA;AAAA,EAGlC,OAAO,kBAAkB;AAAA,EAEf,cAA6B;AAAA,EAC7B,SAAc,CAAC;AAAA,EACf,gBAAqB,CAAC;AAAA,EACtB,MAAW;AAAA,EAGrB,YAAY,KAAU,gBAAqB,CAAC,GAAG;AAC3C,SAAK,gBAAgB;AACrB,SAAK,MAAM;AAAA,EACf;AAAA,EAEA,MAAM,OAAO;AAET,QAAI,KAAK,cAAc,SAAS;AAC5B,WAAK,cAAc,KAAK,cAAc;AAAA,IAC1C,OAAO;AACH,WAAK,cAAc,MAAM,gBAAgB,KAAK,IAAI,MAAM,QAAQ,IAAI,CAAC;AAAA,IACzE;AAEA,UAAM,kBAAmB,KAAK,YAAoB;AAElD,QAAI,mBAAmB,CAAC,KAAK,aAAa;AACtC,WAAK,MAAM,8EAA8E,CAAC;AAC1F;AAAA,IACJ;AAEA,QAAI,KAAK,aAAa;AAClB,WAAK,SAAS,MAAM,WAAW,KAAK,IAAI,MAAM,KAAK,WAAW;AAAA,IAElE;AAAA,EACJ;AAAA;AAAA,EAKA,QAAQ,KAAa;AACjB,WAAO,QAAQ,GAAG;AAAA,EACtB;AAAA,EAGA,KAAK,KAAa;AACd,WAAO,KAAK,GAAG;AAAA,EACnB;AAAA,EAEA,KAAK,KAAa;AACd,WAAO,KAAK,GAAG;AAAA,EACnB;AAAA,EAEA,MAAM,KAAqB,OAAO,GAAG;AACjC,QAAI,eAAe,OAAO;AACtB,aAAO,MAAM,IAAI,OAAO;AACxB,UAAI,KAAK,cAAc,OAAO;AAC1B,eAAO,MAAM,IAAI,KAAK;AAAA,MAC1B;AAAA,IACJ,OAAO;AACH,aAAO,MAAM,GAAG;AAAA,IACpB;AACA,YAAQ,KAAK,IAAI;AAAA,EACrB;AACJ;","names":[]}

package/dist/chunk-IIOHHU2E.js

@@ -0,0 +1,48 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+import {
+  logger
+} from "./chunk-2HJDWSDA.js";
+
+// src/utils/config.ts
+import { lilconfig } from "lilconfig";
+import path from "path";
+import YAML from "yaml";
+var loadYaml = (filepath, content) => {
+  return YAML.parse(content);
+};
+async function findProjectRoot(commandName, startDir) {
+  const searchPlaces = [`${commandName}.yml`, `${commandName}.yaml`];
+  const explorer = lilconfig(commandName, {
+    searchPlaces,
+    loaders: {
+      ".yml": loadYaml,
+      ".yaml": loadYaml
+    }
+  });
+  const result = await explorer.search(startDir);
+  if (result) {
+    logger.debug(`Project root found at: ${path.dirname(result.filepath)}`);
+    return path.dirname(result.filepath);
+  }
+  return null;
+}
+async function loadConfig(commandName, rootDir) {
+  const searchPlaces = [`${commandName}.yml`, `${commandName}.yaml`];
+  const explorer = lilconfig(commandName, {
+    searchPlaces,
+    loaders: {
+      ".yml": loadYaml,
+      ".yaml": loadYaml
+    }
+  });
+  const result = await explorer.search(rootDir);
+  logger.debug(result ? `Loaded config from ${result.filepath}` : `No config found in ${rootDir}`);
+  return result ? result.config : {};
+}
+
+export {
+  loadYaml,
+  findProjectRoot,
+  loadConfig
+};
+//# sourceMappingURL=chunk-IIOHHU2E.js.map

package/dist/chunk-IIOHHU2E.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/config.ts"],"sourcesContent":["import { lilconfig, type Loader } from 'lilconfig';\nimport path from 'node:path';\nimport YAML from 'yaml';\nimport { logger } from './logger.js';\n\nexport const loadYaml: Loader = (filepath, content) => {\n    return YAML.parse(content);\n};\n\nexport async function findProjectRoot(commandName: string, startDir: string): Promise<string | null> {\n    const searchPlaces = [`${commandName}.yml`, `${commandName}.yaml`];\n\n    // We use lilconfig to find the file up the tree\n    const explorer = lilconfig(commandName, {\n        searchPlaces,\n        loaders: {\n            '.yml': loadYaml,\n            '.yaml': loadYaml,\n        }\n    });\n\n    const result = await explorer.search(startDir);\n    if (result) {\n        logger.debug(`Project root found at: ${path.dirname(result.filepath)}`);\n        return path.dirname(result.filepath);\n    }\n\n    return null;\n}\n\nexport async function loadConfig(commandName: string, rootDir: string): Promise<any> {\n    const searchPlaces = [`${commandName}.yml`, `${commandName}.yaml`];\n    const explorer = lilconfig(commandName, {\n        searchPlaces,\n        loaders: {\n            '.yml': loadYaml,\n            '.yaml': loadYaml,\n        }\n    });\n    const result = await explorer.search(rootDir);\n    logger.debug(result ? `Loaded config from ${result.filepath}` : `No config found in ${rootDir}`);\n    return result ? result.config : {};\n}\n"],"mappings":";;;;;;AAAA,SAAS,iBAA8B;AACvC,OAAO,UAAU;AACjB,OAAO,UAAU;AAGV,IAAM,WAAmB,CAAC,UAAU,YAAY;AACnD,SAAO,KAAK,MAAM,OAAO;AAC7B;AAEA,eAAsB,gBAAgB,aAAqB,UAA0C;AACjG,QAAM,eAAe,CAAC,GAAG,WAAW,QAAQ,GAAG,WAAW,OAAO;AAGjE,QAAM,WAAW,UAAU,aAAa;AAAA,IACpC;AAAA,IACA,SAAS;AAAA,MACL,QAAQ;AAAA,MACR,SAAS;AAAA,IACb;AAAA,EACJ,CAAC;AAED,QAAM,SAAS,MAAM,SAAS,OAAO,QAAQ;AAC7C,MAAI,QAAQ;AACR,WAAO,MAAM,0BAA0B,KAAK,QAAQ,OAAO,QAAQ,CAAC,EAAE;AACtE,WAAO,KAAK,QAAQ,OAAO,QAAQ;AAAA,EACvC;AAEA,SAAO;AACX;AAEA,eAAsB,WAAW,aAAqB,SAA+B;AACjF,QAAM,eAAe,CAAC,GAAG,WAAW,QAAQ,GAAG,WAAW,OAAO;AACjE,QAAM,WAAW,UAAU,aAAa;AAAA,IACpC;AAAA,IACA,SAAS;AAAA,MACL,QAAQ;AAAA,MACR,SAAS;AAAA,IACb;AAAA,EACJ,CAAC;AACD,QAAM,SAAS,MAAM,SAAS,OAAO,OAAO;AAC5C,SAAO,MAAM,SAAS,sBAAsB,OAAO,QAAQ,KAAK,sBAAsB,OAAO,EAAE;AAC/F,SAAO,SAAS,OAAO,SAAS,CAAC;AACrC;","names":[]}

package/dist/chunk-LLXEFSKN.js

@@ -0,0 +1,69 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+import {
+  logger
+} from "./chunk-2HJDWSDA.js";
+
+// src/CommandLoader.ts
+import fs from "fs";
+import path from "path";
+var CommandLoader = class {
+  cli = null;
+  commands = [];
+  importer;
+  constructor(cli, importer = (p) => import(p)) {
+    this.cli = cli;
+    this.importer = importer;
+  }
+  getCommands() {
+    return this.commands;
+  }
+  async load(commandsDir) {
+    logger.debug(`Loading commands from: ${commandsDir}`);
+    if (!fs.existsSync(commandsDir)) {
+      logger.debug(`Commands directory not found: ${commandsDir}`);
+      return [];
+    }
+    await this.scan(commandsDir, []);
+    return this.commands;
+  }
+  async scan(dir, prefix) {
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+      const fullPath = path.join(dir, file);
+      const stat = fs.statSync(fullPath);
+      if (stat.isDirectory()) {
+        await this.scan(fullPath, [...prefix, file]);
+      } else if ((file.endsWith(".ts") || file.endsWith(".js")) && !file.endsWith(".d.ts")) {
+        logger.debug(`Found potential command file: ${fullPath}`);
+        const name = path.basename(file, path.extname(file));
+        const commandParts = [...prefix];
+        if (name !== "index") {
+          commandParts.push(name);
+        } else if (commandParts.length === 0) {
+          continue;
+        }
+        try {
+          const module = await this.importer(fullPath);
+          const CommandClass = module.default;
+          if (CommandClass) {
+            const commandName = commandParts.join(" ");
+            logger.debug(`Registered command: ${commandName}`);
+            this.commands.push({
+              command: commandName,
+              path: fullPath,
+              instance: new CommandClass(this.cli),
+              class: CommandClass
+            });
+          }
+        } catch (e) {
+          logger.error(`Failed to load command at ${fullPath}`, e);
+        }
+      }
+    }
+  }
+};
+
+export {
+  CommandLoader
+};
+//# sourceMappingURL=chunk-LLXEFSKN.js.map

package/dist/chunk-LLXEFSKN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/CommandLoader.ts"],"sourcesContent":["import fs from 'node:fs';\nimport path from 'node:path';\nimport { BaseCommand } from './BaseCommand.js';\nimport { logger } from './utils/logger.js';\n\nexport interface LoadedCommand {\n    command: string;\n    path: string;\n    instance: BaseCommand;\n    class: any;\n}\n\nexport class CommandLoader {\n    private cli: any = null;\n    private commands: LoadedCommand[] = [];\n    private importer: (path: string) => Promise<any>;\n\n    constructor(cli: any, importer: (path: string) => Promise<any> = (p) => import(p)) {\n        this.cli = cli;\n        this.importer = importer;\n    }\n\n    getCommands(): LoadedCommand[] {\n        return this.commands;\n    }\n\n    async load(commandsDir: string): Promise<LoadedCommand[]> {\n        logger.debug(`Loading commands from: ${commandsDir}`);\n        if (!fs.existsSync(commandsDir)) {\n            logger.debug(`Commands directory not found: ${commandsDir}`);\n            return [];\n        }\n\n        await this.scan(commandsDir, []);\n        return this.commands;\n    }\n\n    private async scan(dir: string, prefix: string[]) {\n        const files = fs.readdirSync(dir);\n\n        for (const file of files) {\n            const fullPath = path.join(dir, file);\n            const stat = fs.statSync(fullPath);\n\n            if (stat.isDirectory()) {\n                await this.scan(fullPath, [...prefix, file]);\n            } else if ((file.endsWith('.ts') || file.endsWith('.js')) && !file.endsWith('.d.ts')) {\n                // Ignore index files or non-command files if needed, but for now scan all.\n                // Assuming \"index.ts\" might be the command for the directory path itself if we supported that,\n                // but let's stick to \"create.ts\" -> \"create\"\n                logger.debug(`Found potential command file: ${fullPath}`);\n\n                const name = path.basename(file, path.extname(file));\n                const commandParts = [...prefix];\n                if (name !== 'index') {\n                    commandParts.push(name);\n                } else if (commandParts.length === 0) {\n                    continue; // skip src/commands/index.ts if it exists and doesn't map to anything specific\n                }\n\n                // Import\n                try {\n                    const module = await this.importer(fullPath);\n                    // Assume default export is the command class\n                    const CommandClass = module.default;\n\n                    if (CommandClass) { // Loose check for now to debug\n                        const commandName = commandParts.join(' ');\n                        logger.debug(`Registered command: ${commandName}`);\n                        this.commands.push({\n                            command: commandName,\n                            path: fullPath,\n                            instance: new CommandClass(this.cli),\n                            class: CommandClass\n                        });\n                    }\n                } catch (e) {\n                    logger.error(`Failed to load command at ${fullPath}`, e);\n                }\n            }\n        }\n    }\n}\n"],"mappings":";;;;;;AAAA,OAAO,QAAQ;AACf,OAAO,UAAU;AAWV,IAAM,gBAAN,MAAoB;AAAA,EACf,MAAW;AAAA,EACX,WAA4B,CAAC;AAAA,EAC7B;AAAA,EAER,YAAY,KAAU,WAA2C,CAAC,MAAM,OAAO,IAAI;AAC/E,SAAK,MAAM;AACX,SAAK,WAAW;AAAA,EACpB;AAAA,EAEA,cAA+B;AAC3B,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,MAAM,KAAK,aAA+C;AACtD,WAAO,MAAM,0BAA0B,WAAW,EAAE;AACpD,QAAI,CAAC,GAAG,WAAW,WAAW,GAAG;AAC7B,aAAO,MAAM,iCAAiC,WAAW,EAAE;AAC3D,aAAO,CAAC;AAAA,IACZ;AAEA,UAAM,KAAK,KAAK,aAAa,CAAC,CAAC;AAC/B,WAAO,KAAK;AAAA,EAChB;AAAA,EAEA,MAAc,KAAK,KAAa,QAAkB;AAC9C,UAAM,QAAQ,GAAG,YAAY,GAAG;AAEhC,eAAW,QAAQ,OAAO;AACtB,YAAM,WAAW,KAAK,KAAK,KAAK,IAAI;AACpC,YAAM,OAAO,GAAG,SAAS,QAAQ;AAEjC,UAAI,KAAK,YAAY,GAAG;AACpB,cAAM,KAAK,KAAK,UAAU,CAAC,GAAG,QAAQ,IAAI,CAAC;AAAA,MAC/C,YAAY,KAAK,SAAS,KAAK,KAAK,KAAK,SAAS,KAAK,MAAM,CAAC,KAAK,SAAS,OAAO,GAAG;AAIlF,eAAO,MAAM,iCAAiC,QAAQ,EAAE;AAExD,cAAM,OAAO,KAAK,SAAS,MAAM,KAAK,QAAQ,IAAI,CAAC;AACnD,cAAM,eAAe,CAAC,GAAG,MAAM;AAC/B,YAAI,SAAS,SAAS;AAClB,uBAAa,KAAK,IAAI;AAAA,QAC1B,WAAW,aAAa,WAAW,GAAG;AAClC;AAAA,QACJ;AAGA,YAAI;AACA,gBAAM,SAAS,MAAM,KAAK,SAAS,QAAQ;AAE3C,gBAAM,eAAe,OAAO;AAE5B,cAAI,cAAc;AACd,kBAAM,cAAc,aAAa,KAAK,GAAG;AACzC,mBAAO,MAAM,uBAAuB,WAAW,EAAE;AACjD,iBAAK,SAAS,KAAK;AAAA,cACf,SAAS;AAAA,cACT,MAAM;AAAA,cACN,UAAU,IAAI,aAAa,KAAK,GAAG;AAAA,cACnC,OAAO;AAAA,YACX,CAAC;AAAA,UACL;AAAA,QACJ,SAAS,GAAG;AACR,iBAAO,MAAM,6BAA6B,QAAQ,IAAI,CAAC;AAAA,QAC3D;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AACJ;","names":[]}

package/dist/chunk-SNTKHUTX.js

@@ -0,0 +1,29 @@
+import { createRequire } from "module"; const require = createRequire(import.meta.url);
+import {
+  logger
+} from "./chunk-2HJDWSDA.js";
+
+// src/utils/shell.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function runCommand(command, cwd) {
+  try {
+    logger.debug(`Executing command: ${command} in ${cwd || process.cwd()}`);
+    const { stdout } = await execAsync(command, { cwd });
+    if (stdout) {
+      console.log(stdout);
+    }
+  } catch (error) {
+    logger.error(`Command failed: ${command}`);
+    if (error.stderr) {
+      logger.error(error.stderr);
+    }
+    throw new Error(`Command failed: ${command}`);
+  }
+}
+
+export {
+  runCommand
+};
+//# sourceMappingURL=chunk-SNTKHUTX.js.map

package/dist/chunk-SNTKHUTX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/shell.ts"],"sourcesContent":["import { exec } from 'node:child_process';\nimport { promisify } from 'node:util';\nimport { logger } from './logger.js';\n\nconst execAsync = promisify(exec);\n\nexport async function runCommand(command: string, cwd?: string): Promise<void> {\n    try {\n        logger.debug(`Executing command: ${command} in ${cwd || process.cwd()}`);\n        const { stdout } = await execAsync(command, { cwd });\n        if (stdout) {\n            console.log(stdout);\n        }\n    } catch (error: any) {\n        logger.error(`Command failed: ${command}`);\n        if (error.stderr) {\n            logger.error(error.stderr);\n        }\n        throw new Error(`Command failed: ${command}`);\n    }\n}\n"],"mappings":";;;;;;AAAA,SAAS,YAAY;AACrB,SAAS,iBAAiB;AAG1B,IAAM,YAAY,UAAU,IAAI;AAEhC,eAAsB,WAAW,SAAiB,KAA6B;AAC3E,MAAI;AACA,WAAO,MAAM,sBAAsB,OAAO,OAAO,OAAO,QAAQ,IAAI,CAAC,EAAE;AACvE,UAAM,EAAE,OAAO,IAAI,MAAM,UAAU,SAAS,EAAE,IAAI,CAAC;AACnD,QAAI,QAAQ;AACR,cAAQ,IAAI,MAAM;AAAA,IACtB;AAAA,EACJ,SAAS,OAAY;AACjB,WAAO,MAAM,mBAAmB,OAAO,EAAE;AACzC,QAAI,MAAM,QAAQ;AACd,aAAO,MAAM,MAAM,MAAM;AAAA,IAC7B;AACA,UAAM,IAAI,MAAM,mBAAmB,OAAO,EAAE;AAAA,EAChD;AACJ;","names":[]}