millas 0.2.29 → 0.2.31

package/src/console/Command.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const chalk = require('chalk');
+const BaseCommand = require("./BaseCommand");
 
 /**
  * Command
@@ -75,45 +76,12 @@ const chalk = require('chalk');
  *   return;              — success (exit 0)
  *   this.fail(msg)       — print error + exit 1
  */
-class Command {
-  /**
-   * The CLI signature — used as the command name.
-   * Use colons for namespacing: 'email:digest', 'cache:clear', 'db:seed'
-   *
-   * @type {string}
-   */
-  static signature = '';
-
-  /**
-   * Short description shown in `millas --help` and `millas list`.
-   *
-   * @type {string}
-   */
-  static description = '';
-
-  /**
-   * Positional arguments.
-   * Each entry: { name: string, description?: string, default?: * }
-   *
-   * @type {Array<{ name: string, description?: string, default?: * }>}
-   */
-  static args = [];
 
-  /**
-   * Named options / flags.
-   * Each entry: { flag: string, description?: string, default?: * }
-   * flag examples: '--dry-run', '--limit <n>', '-f, --force'
-   *
-   * @type {Array<{ flag: string, description?: string, default?: * }>}
-   */
-  static options = [];
-
-  // ── Internal ───────────────────────────────────────────────────────────────
-
-  constructor() {
-    this._args    = {};
-    this._opts    = {};
-  }
+/**
+ * @typedef {Object} SecreteOptions
+ * @property {{mesage?:string,error?:string,retry?:boolean}} [confirm] - Needs secrete Confirmation
+ */
+class Command extends BaseCommand{
 
   /**
    * Populate the command with parsed CLI values.
@@ -128,56 +96,72 @@ class Command {
     this._opts = options || {};
   }
 
-  // ── Input ──────────────────────────────────────────────────────────────────
-
-  /**
-   * Get a positional argument value by name.
-   *
-   *   const name = this.argument('name');
-   *
-   * @param {string} name
-   * @returns {*}
-   */
-  argument(name) {
-    return this._args[name];
-  }
-
-  /**
-   * Get an option value by name (camelCase).
-   * Flags like --dry-run become dryRun.
-   *
-   *   const limit = this.option('limit');
-   *   const dry   = this.option('dryRun');
-   *
-   * @param {string} name
-   * @returns {*}
-   */
-  option(name) {
-    return this._opts[name];
-  }
-
   /**
    * Prompt the user for input.
    *
    *   const name = await this.ask('What is your name?');
+   *   const name = await this.ask('What is your name?', 'Anonymous');
+   *   const age  = await this.ask('Your age?', null, v => Number.isInteger(+v) || 'Must be a number');
    *
-   * @param {string} question
+   * @param {string}                          question
+   * @param {string|null}                     [defaultValue=null]
+   * @param {(v:string)=>true|string}         [validate]   — return true to accept, or an error string
    * @returns {Promise<string>}
    */
-  ask(question) {
-    return _prompt(question + ' ');
+  async ask(question, defaultValue = null, validate = null) {
+    const hint   = defaultValue != null ? chalk.dim(` [${defaultValue}]`) : '';
+    const prompt = `${question}${hint} `;
+
+    while (true) {
+      const raw    = await _prompt(prompt);
+      const answer = raw.trim() || (defaultValue ?? '');
+
+      if (validate) {
+        const result = validate(answer);
+        if (result !== true) {
+          this.error(typeof result === 'string' ? result : 'Invalid input.');
+          continue;
+        }
+      }
+
+      return answer;
+    }
   }
 
   /**
    * Prompt the user for a secret (input hidden — for passwords).
    *
    *   const pass = await this.secret('Password:');
+   *   const pass = await this.secret('Password:', { confirm: { message: 'Confirm:' } });
+   *   const pass = await this.secret('Password:', { validate: v => v.length >= 8 || 'Min 8 chars' });
    *
    * @param {string} question
+   * @param {{ confirm?: { message?: string, error?: string, retry?: boolean }, validate?: (v: string) => true|string }} [options]
    * @returns {Promise<string>}
    */
-  secret(question) {
-    return _promptSecret(question + ' ');
+  async secret(question, options = {}) {
+    while (true) {
+      const first = await _promptSecret(question + ' ');
+
+      if (options.validate) {
+        const result = options.validate(first);
+        if (result !== true) {
+          this.error(typeof result === 'string' ? result : 'Invalid input.');
+          continue;
+        }
+      }
+
+      if (options.confirm) {
+        const second = await _promptSecret(options.confirm.message ?? 'Confirm: ');
+        if (first !== second) {
+          this.error(options.confirm.error ?? "Inputs don't match!");
+          if (options.confirm.retry) continue;
+          return null;
+        }
+      }
+
+      return first;
+    }
   }
 
   /**
@@ -198,71 +182,8 @@ class Command {
     return trimmed === 'y' || trimmed === 'yes';
   }
 
-  // ── Output ─────────────────────────────────────────────────────────────────
-
-  /**
-   * Write a plain line to stdout.
-   * @param {string} [msg='']
-   */
-  line(msg = '') {
-    process.stdout.write(msg + '\n');
-  }
-
-  /**
-   * Write a blank line.
-   */
-  newLine() {
-    process.stdout.write('\n');
-  }
-
-  /**
-   * Informational message (cyan).
-   * @param {string} msg
-   */
-  info(msg) {
-    this.line(chalk.cyan(`  ${msg}`));
-  }
-
-  /**
-   * Success message (green ✔).
-   * @param {string} msg
-   */
-  success(msg) {
-    this.line(chalk.green(`  ✔  ${msg}`));
-  }
-
-  /**
-   * Warning message (yellow ⚠).
-   * @param {string} msg
-   */
-  warn(msg) {
-    this.line(chalk.yellow(`  ⚠  ${msg}`));
-  }
 
-  /**
-   * Error message (red ✖). Does NOT exit — use fail() to exit.
-   * @param {string} msg
-   */
-  error(msg) {
-    this.line(chalk.red(`  ✖  ${msg}`));
-  }
-
-  /**
-   * Dimmed / comment message.
-   * @param {string} msg
-   */
-  comment(msg) {
-    this.line(chalk.dim(`  // ${msg}`));
-  }
 
-  /**
-   * Print an error and exit with code 1.
-   * @param {string} msg
-   */
-  fail(msg) {
-    this.error(msg);
-    process.exit(1);
-  }
 
   /**
    * Render a simple table.
@@ -299,16 +220,7 @@ class Command {
     this.newLine();
   }
 
-  // ── Lifecycle ──────────────────────────────────────────────────────────────
 
-  /**
-   * The command's entry point. Override this in your command.
-   *
-   * @returns {Promise<void>}
-   */
-  async handle() {
-    throw new Error(`[Command] "${this.constructor.signature}" must implement handle().`);
-  }
 }
 
 // ── Prompt helpers ────────────────────────────────────────────────────────────

package/src/console/CommandContext.js

@@ -45,21 +45,7 @@ class CommandContext {
   isMillasProject() {
     const fs = require('fs');
     const path = require('path');
-    
-    const pkgPath = path.join(this.cwd, 'package.json');
-    if (!fs.existsSync(pkgPath)) {
-      return false;
-    }
-    
-    try {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-      // Check for millas marker in package.json
-      return pkg.millas === true || 
-             (pkg.dependencies && 'millas' in pkg.dependencies) ||
-             (pkg.devDependencies && 'millas' in pkg.devDependencies);
-    } catch {
-      return false;
-    }
+    return fs.existsSync(path.join(this.cwd, 'millas.config.js'));
   }
 }
 

package/src/console/CommandRegistry.js

@@ -45,26 +45,63 @@ class CommandRegistry {
    */
   async loadCommand(commandPath) {
     const CommandClass = require(commandPath);
-    const BaseCommand = require('./BaseCommand');
-    
-    // Support both class-based and function-based commands
-    if (typeof CommandClass === 'function') {
-      // Check if it's a class extending BaseCommand
-      if (CommandClass.prototype instanceof BaseCommand) {
-        const commandInstance = new CommandClass(this.context);
-        await commandInstance.register(); // Now async
-        this.commands.set(commandPath, commandInstance);
-      }
-      // Legacy function-based command (backward compatibility)
-      // else if (CommandClass.length === 1) { // expects (program) argument
-      //   CommandClass(this.context.program);
-      //   this.commands.set(commandPath, CommandClass);
-      // }
-      // Invalid command export
-      // else {
-      //   throw new Error(`Invalid command export in ${commandPath}. Must extend BaseCommand or export function(program).`);
-      // }
+    const Command = require('./Command');
+
+    if (typeof CommandClass !== 'function' || !(CommandClass.prototype instanceof Command)) return;
+
+    const commandInstance = new CommandClass(this.context);
+    commandInstance._filename = path.basename(commandPath, '.js');
+
+    // Collect subcommand names the user intends to register
+    // by running onInit against a dry registrar that only records names
+    const namespace = commandInstance.constructor.namespace
+      || commandInstance._filename.toLowerCase();
+
+    const userSubcommandNames = await this.#collectSubcommandNames(commandInstance, namespace);
+
+    // Remove any conflicting built-in subcommands from Commander
+    for (const fullName of userSubcommandNames) {
+      const existing = this.context.program.commands.findIndex(c => c.name() === fullName);
+      if (existing !== -1) this.context.program.commands.splice(existing, 1);
     }
+
+    await commandInstance.register();
+    this.commands.set(namespace, commandInstance);
+  }
+
+  async #collectSubcommandNames(instance, namespace) {
+    if (typeof instance.onInit !== 'function') return [namespace];
+
+    const names = [];
+    const dryRegistrar = {
+      _last: null,
+      command(fn) { this._last = { name: fn.name || 'anonymous' }; return this; },
+      name(n)    { if (this._last) this._last.name = n; return this; },
+      // absorb all chaining methods
+      ...Object.fromEntries(
+        ['arg','str','num','bool','email','enum','option','argument',
+         'description','aliases','before','after','validate','onError']
+          .map(m => [m, function() { return this; }])
+      ),
+      _flush(ns) {
+        if (this._last) {
+          names.push(this._last.name === ns ? ns : `${ns}:${this._last.name}`);
+          this._last = null;
+        }
+      },
+    };
+
+    // Wrap command() to flush previous before starting next
+    const origCommand = dryRegistrar.command.bind(dryRegistrar);
+    dryRegistrar.command = function(fn) {
+      this._flush(namespace);
+      return origCommand(fn);
+    };
+
+    await instance.onInit(dryRegistrar);
+    dryRegistrar._flush(namespace);
+
+    return names;
   }
 
   /**

package/src/console/index.js

@@ -1,15 +1,11 @@
 'use strict';
 
 const Command         = require('./Command');
-const CommandLoader   = require('./CommandLoader');
-const BaseCommand     = require('./BaseCommand');
 const CommandContext  = require('./CommandContext');
 const CommandRegistry = require('./CommandRegistry');
 
 module.exports = { 
   Command, 
-  CommandLoader, 
-  BaseCommand, 
   CommandContext, 
   CommandRegistry 
 };

package/src/container/AppInitializer.js

@@ -236,7 +236,7 @@ class AppInitializer {
             } else {
                 env = nunjucks.configure(viewsDir, {
                     autoescape:    viewsConfig.autoescape    ?? true,
-                    watch:         viewsConfig.watch         ?? (process.env.NODE_ENV !== 'production'),
+                    watch:         viewsConfig.watch         ?? (process.env.NODE_ENV !== 'production' && !process.env.MILLAS_CLI_MODE),
                     noCache:       viewsConfig.noCache       ?? (process.env.NODE_ENV !== 'production'),
                     throwOnUndefined: viewsConfig.throwOnUndefined ?? false,
                     express:       expressApp,

package/src/providers/ProviderRegistry.js

@@ -77,8 +77,11 @@ class ProviderRegistry {
     }
 
     // Phase 2: boot all providers (async-safe)
+    // Providers with static cli = false are skipped in CLI mode
+    const isCli = !!process.env.MILLAS_CLI_MODE;
     for (const provider of this._providers) {
       if (typeof provider.boot === 'function') {
+        if (isCli && provider.constructor.cli === false) continue;
         await provider.boot(this._container, this._app);
       }
     }

package/src/scheduler/TaskScheduler.js

@@ -69,7 +69,7 @@ class TaskScheduler {
    * Start the scheduler
    */
   start() {
-    if (!this._config.enabled || this._running) return;
+    if (!this._config.enabled || this._running || process.env.MILLAS_CLI_MODE) return;
 
     this._running = true;
     

package/src/templates/command/default.template.js

@@ -1,12 +1,15 @@
-module.exports = `const { BaseCommand } = require('millas/src/console');
+module.exports = `const { Command } = require('millas/console');
 
-class {{ name | pascalCase }}Command extends BaseCommand {
-  static signature = '{{ name | kebabCase }}';
+class {{ name | pascalCase }}Command extends Command {
   static description = '{{ name | pascalCase }} command description';
 
-  async run(args, opts) {
-    this.info('Running {{ name | pascalCase }}Command');
-    // Command logic here
+  async onInit(register) {
+    register
+      .command(async () => {
+        this.info('Running {{ name | pascalCase }}');
+        // Command logic here
+      })
+      .description('{{ name | pascalCase }} command description');
   }
 }
 

package/src/commands/call.js

@@ -1,190 +0,0 @@
-'use strict';
-
-const chalk = require('chalk');
-const path  = require('path');
-const fs    = require('fs');
-
-/**
- * `millas call <signature> [args] [options]`
- *
- * Discovers all commands in app/commands/, then either:
- *   - Runs the matched command directly, OR
- *   - Lists all available commands when no signature is given
- *
- * Each command in app/commands/ must extend Command and have a static `signature`.
- *
- * ── Examples ─────────────────────────────────────────────────────────────────
- *
- *   millas call                        — list all custom commands
- *   millas call email:digest           — run with defaults
- *   millas call email:digest weekly    — positional arg
- *   millas call email:digest --dry-run — flag
- */
-module.exports = function (program) {
-  const commandsDir = path.resolve(process.cwd(), 'app/commands');
-  const CommandLoader = require('../console/CommandLoader');
-
-  // ── Bootstrap helpers ──────────────────────────────────────────────────────
-  async function bootstrapApp() {
-    const bootstrapPath = path.join(process.cwd(), 'bootstrap/app.js');
-    if (!fs.existsSync(bootstrapPath)) return;
-    
-    // require('dotenv').config({ path: path.resolve(process.cwd(), '.env') });
-    
-    const basePath = process.cwd();
-    const AppServiceProvider = require(path.join(basePath, 'providers/AppServiceProvider'));
-    const AppInitializer = require('../container/AppInitializer');
-    
-    const config = {
-      basePath,
-      providers: [AppServiceProvider],
-      routes: null,
-      middleware: [],
-      logging: true,
-      database: true,
-      auth: true,
-      cache: true,
-      storage: true,
-      mail: true,
-      queue: true,
-      events: true,
-      admin: null,
-      docs: null,
-      adapterMiddleware: [],
-    };
-    
-    const initializer = new AppInitializer(config);
-    await initializer.bootKernel();
-  }
-
-  async function closeDb() {
-    try {
-      const DatabaseManager = require('../orm/drivers/DatabaseManager');
-      await DatabaseManager.closeAll();
-    } catch {}
-  }
-
-  // ── millas list ────────────────────────────────────────────────────────────
-  program
-    .command('list')
-    .description('List all available custom commands')
-    .action(() => {
-      if (!fs.existsSync(commandsDir)) {
-        console.log(chalk.yellow('\n  No app/commands/ directory found.\n'));
-        console.log(chalk.dim('  Run: millas make:command <Name>  to create your first command.\n'));
-        return;
-      }
-
-      const loader = new CommandLoader(commandsDir);
-      loader.load();
-      const sigs = loader.signatures();
-
-      if (sigs.length === 0) {
-        console.log(chalk.yellow('\n  No custom commands found in app/commands/.\n'));
-        console.log(chalk.dim('  Run: millas make:command <Name>  to create one.\n'));
-        return;
-      }
-
-      const maxLen = Math.max(...sigs.map(s => s.length));
-
-      console.log(chalk.bold('\n  Available commands:\n'));
-      for (const [sig, CommandClass] of loader._commands) {
-        const desc = CommandClass.description || '';
-        console.log(
-          '  ' + chalk.cyan(sig.padEnd(maxLen + 2)) +
-          chalk.dim(desc)
-        );
-      }
-      console.log();
-    });
-
-  // ── millas call <signature> ────────────────────────────────────────────────
-  // Uses Commander's allowUnknownOption + passThroughOptions so we can
-  // forward all args/options to the matched command.
-  const callCmd = program
-    .command('call <signature> [args...]')
-    .description('Run a custom command from app/commands/')
-    .allowUnknownOption(true)
-    .passThroughOptions(true)
-    .action((signature, extraArgs, options, cmd) => {
-      if (!fs.existsSync(commandsDir)) {
-        console.error(chalk.red('\n  ✖  No app/commands/ directory found.\n'));
-        console.error(chalk.dim('  Run: millas make:command <Name>  to create your first command.\n'));
-        process.exit(1);
-      }
-
-      const loader = new CommandLoader(commandsDir);
-      loader.load();
-
-      const CommandClass = loader._commands.get(signature);
-
-      if (!CommandClass) {
-        const sigs = loader.signatures();
-        console.error(chalk.red(`\n  ✖  Unknown command: ${chalk.bold(signature)}\n`));
-        if (sigs.length) {
-          console.log(chalk.dim('  Available commands:'));
-          for (const s of sigs) console.log(chalk.dim(`    ${s}`));
-        } else {
-          console.log(chalk.dim('  No custom commands found. Run: millas make:command <Name>'));
-        }
-        console.log();
-        process.exit(1);
-      }
-
-      // Re-parse args + options against the command's own definition
-      const { Command: CommanderCmd } = require('commander');
-      const sub = new CommanderCmd(signature);
-
-      const argsDef = CommandClass.args    || [];
-      const optsDef = CommandClass.options || [];
-
-      for (const a of argsDef) {
-        sub.argument(
-          a.default !== undefined ? `[${a.name}]` : `<${a.name}>`,
-          a.description || '',
-          a.default
-        );
-      }
-      for (const o of optsDef) {
-        if (o.default !== undefined) {
-          sub.option(o.flag, o.description || '', o.default);
-        } else {
-          sub.option(o.flag, o.description || '');
-        }
-      }
-
-      // Combine extraArgs back with the raw unknown options Commander captured
-      const rawArgs = [...(extraArgs || []), ...(cmd.args || [])];
-
-      // Re-deduplicate (Commander may put some into cmd.args already)
-      const allRaw = [...new Set([...extraArgs, ...rawArgs])];
-
-      sub.parse([process.execPath, signature, ...allRaw]);
-
-      const parsedOpts    = sub.opts();
-      const parsedPosArgs = sub.args;
-
-      const argMap = {};
-      for (let i = 0; i < argsDef.length; i++) {
-        argMap[argsDef[i].name] = parsedPosArgs[i] !== undefined
-          ? parsedPosArgs[i]
-          : argsDef[i].default;
-      }
-
-      const instance = new CommandClass();
-      instance._hydrate(argMap, parsedOpts);
-
-      // Prevent HTTP server from starting during CLI commands
-      process.env.MILLAS_CLI_MODE = '1';
-
-      Promise.resolve()
-        .then(() => bootstrapApp())
-        .then(() => instance.handle())
-        .catch(err => {
-          console.error(chalk.red(`\n  ✖  ${signature} failed: ${err.message}\n`));
-          if (process.env.DEBUG) console.error(err.stack);
-          process.exit(1);
-        })
-        .finally(() => closeDb());
-    });
-};