go-dev 0.4.2 → 0.5.0

package/src/cli-args.js

@@ -0,0 +1,83 @@
+/**
+ * Parses go-dev CLI arguments.
+ *
+ * Recognizes:
+ *   <preset>                                   — positional preset name (first non-flag arg)
+ *   -c <path>,  --config <path>,  -c=<path>,    --config=<path>
+ *   -l <level>, --log-level <level>, -l=<lvl>,  --log-level=<lvl>
+ *
+ * Flags are only interpreted before the first `--args-for` token. Everything
+ * from `--args-for` onward is preserved verbatim in `remaining` so the
+ * orchestrator's per-service args parser can consume it untouched.
+ *
+ * @param {string[]} argv - argv tail (already stripped of node + script path).
+ * @returns {{ presetName?: string, configPath?: string, logLevel?: string, remaining: string[] }}
+ */
+function parseCliArgs(argv) {
+  let presetName;
+  let configPath;
+  let logLevel;
+  const remaining = [];
+
+  let i = 0;
+  for (; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg === '--args-for') {
+      break;
+    }
+
+    if (arg === '-c' || arg === '--config') {
+      const value = argv[i + 1];
+      if (value == null) {
+        throw new Error(`'${arg}' flag requires a path argument.`);
+      }
+      configPath = value;
+      i++;
+      continue;
+    }
+
+    if (arg.startsWith('--config=')) {
+      configPath = arg.slice('--config='.length);
+      continue;
+    }
+    if (arg.startsWith('-c=')) {
+      configPath = arg.slice('-c='.length);
+      continue;
+    }
+
+    if (arg === '-l' || arg === '--log-level') {
+      const value = argv[i + 1];
+      if (value == null) {
+        throw new Error(`'${arg}' flag requires a level argument (error|warn|info|debug).`);
+      }
+      logLevel = value;
+      i++;
+      continue;
+    }
+
+    if (arg.startsWith('--log-level=')) {
+      logLevel = arg.slice('--log-level='.length);
+      continue;
+    }
+    if (arg.startsWith('-l=')) {
+      logLevel = arg.slice('-l='.length);
+      continue;
+    }
+
+    if (presetName == null && !arg.startsWith('-')) {
+      presetName = arg;
+      continue;
+    }
+
+    remaining.push(arg);
+  }
+
+  for (; i < argv.length; i++) {
+    remaining.push(argv[i]);
+  }
+
+  return { presetName, configPath, logLevel, remaining };
+}
+
+module.exports = { parseCliArgs };

package/src/config.js

@@ -1,123 +1,134 @@
-const Joi = require('joi');
-const yaml = require('js-yaml');
-const fs = require('fs');
-
-const dependencyEntrySchema = Joi.alternatives().try(
-  Joi.string(),
-  Joi.object({
-    service: Joi.string().required(),
-    mode: Joi.string().required()
-  })
-);
-
-const commandSchema = Joi.array().items(Joi.string().min(1)).min(1);
-const commandObjectSchema = Joi.object({
-    command: commandSchema,
-    directory: Joi.string().min(1).optional(),
-    restartOnError: Joi.boolean().optional(),
-})
-const commandConfigSchema = Joi.alternatives().try(
-    commandSchema,
-    commandObjectSchema
-);
-
-const cmdServiceConfigSchema = Joi.object({
-  type: Joi.string().valid('cmd').required(),
-  preCommands: Joi.array().items(commandConfigSchema).default([]),
-  commands: Joi.alternatives().try(
-    commandConfigSchema,
-    Joi.array().items(commandObjectSchema).min(1)
-  ),
-  defaultCommand: Joi.string().default('start'),
-  directory: Joi.string(),
-  dependencies: Joi.array().items(dependencyEntrySchema).default([]),
-  healthCheck: Joi.boolean().default(false)
-});
-
-const dockerServiceConfigSchema = Joi.object({
-  type: Joi.string().valid('docker').required(),
-  service: Joi.string().required(),
-  composeFile: Joi.string().default('docker-compose.yml'),
-  dependencies: Joi.array().items(dependencyEntrySchema).default([]),
-  healthCheck: Joi.boolean().default(true)
-});
-
-const serviceSchema = Joi.alternatives().try(
-  cmdServiceConfigSchema,
-  dockerServiceConfigSchema,
-  Joi.object({
-    type: Joi.string().valid('hybrid').required(),
-    defaultMode: Joi.string(),
-    modes: Joi.object().pattern(
-      Joi.string(),
-      Joi.alternatives().try(
-        cmdServiceConfigSchema,
-        dockerServiceConfigSchema
-      )
-    ).min(2).required()
-  })
-);
-
-const configSchema = Joi.object({
-  serviceArgsKeyword: Joi.string().min(1).optional(),
-  services: Joi.object().pattern(Joi.string(), serviceSchema).required(),
-  presets: Joi.object().pattern(
-    Joi.string(),
-    Joi.object({
-      services: Joi.array().items(Joi.string()).required(),
-      modes: Joi.object().pattern(Joi.string(), Joi.string()).default({})
-    })
-  ).default({})
-});
-
-const possibleNames = [
-  'go-dev'
-].flatMap(baseName => {
-  return [
-    baseName,
-    `.${baseName}`
-  ];
-}).flatMap(baseName => {
-  return [
-      baseName,
-      `${baseName}.config`
-  ];
-}).flatMap(baseName => {
-  return [
-      `${baseName}.yml`,
-      `${baseName}.yaml`
-  ];
-});
-
-function findConfigFile() {
-  for (const name of possibleNames) {
-    if (fs.existsSync(name)) {
-      return name;
-    }
-  }
-
-  throw new Error(`No config file found. Expected one of: ${possibleNames.join(', ')}`);
-}
-
-function loadConfig(configPath) {
-  if (!configPath) {
-    configPath = findConfigFile();
-  }
-  
-  if (!fs.existsSync(configPath)) {
-    throw new Error(`Config file not found: ${configPath}`);
-  }
-  
-  const configContent = fs.readFileSync(configPath, 'utf8');
-  const config = yaml.load(configContent);
-
-  const { error, value } = configSchema.validate(config);
-  
-  if (error) {
-    throw new Error(`Invalid config: ${error.message}`);
-  }
-  
-  return value;
-}
-
+const Joi = require('joi');
+const yaml = require('js-yaml');
+const fs = require('fs');
+
+const dependencyEntrySchema = Joi.alternatives().try(
+  Joi.string(),
+  Joi.object({
+    service: Joi.string().required(),
+    mode: Joi.string().required()
+  })
+);
+
+const commandSchema = Joi.array().items(Joi.string().min(1)).min(1);
+const commandObjectSchema = Joi.object({
+    command: commandSchema,
+    directory: Joi.string().min(1).optional(),
+    restartOnError: Joi.boolean().optional(),
+})
+const commandConfigSchema = Joi.alternatives().try(
+    commandSchema,
+    commandObjectSchema
+);
+
+const serviceRefSchema = Joi.object({
+    service: Joi.string().min(1).required(),
+    mode: Joi.string().min(1).optional(),
+});
+const preCommandConfigSchema = Joi.alternatives().try(
+    commandSchema,
+    commandObjectSchema,
+    serviceRefSchema,
+);
+
+const cmdServiceConfigSchema = Joi.object({
+  type: Joi.string().valid('cmd').required(),
+  preCommands: Joi.array().items(preCommandConfigSchema).default([]),
+  commands: Joi.alternatives().try(
+    commandConfigSchema,
+    Joi.array().items(commandObjectSchema).min(1)
+  ),
+  defaultCommand: Joi.string().default('start'),
+  directory: Joi.string(),
+  dependencies: Joi.array().items(dependencyEntrySchema).default([]),
+  healthCheck: Joi.boolean().default(false)
+});
+
+const dockerServiceConfigSchema = Joi.object({
+  type: Joi.string().valid('docker').required(),
+  service: Joi.string().required(),
+  composeFile: Joi.string().default('docker-compose.yml'),
+  dependencies: Joi.array().items(dependencyEntrySchema).default([]),
+  healthCheck: Joi.boolean().default(true)
+});
+
+const serviceSchema = Joi.alternatives().try(
+  cmdServiceConfigSchema,
+  dockerServiceConfigSchema,
+  Joi.object({
+    type: Joi.string().valid('hybrid').required(),
+    defaultMode: Joi.string(),
+    modes: Joi.object().pattern(
+      Joi.string(),
+      Joi.alternatives().try(
+        cmdServiceConfigSchema,
+        dockerServiceConfigSchema
+      )
+    ).min(2).required()
+  })
+);
+
+const configSchema = Joi.object({
+  serviceArgsKeyword: Joi.string().min(1).optional(),
+  logLevel: Joi.string().valid('error', 'warn', 'info', 'debug').optional(),
+  services: Joi.object().pattern(Joi.string(), serviceSchema).required(),
+  presets: Joi.object().pattern(
+    Joi.string(),
+    Joi.object({
+      services: Joi.array().items(Joi.string()).required(),
+      modes: Joi.object().pattern(Joi.string(), Joi.string()).default({})
+    })
+  ).default({})
+});
+
+const possibleNames = [
+  'go-dev'
+].flatMap(baseName => {
+  return [
+    baseName,
+    `.${baseName}`
+  ];
+}).flatMap(baseName => {
+  return [
+      baseName,
+      `${baseName}.config`
+  ];
+}).flatMap(baseName => {
+  return [
+      `${baseName}.yml`,
+      `${baseName}.yaml`
+  ];
+});
+
+function findConfigFile() {
+  for (const name of possibleNames) {
+    if (fs.existsSync(name)) {
+      return name;
+    }
+  }
+
+  throw new Error(`No config file found. Expected one of: ${possibleNames.join(', ')}`);
+}
+
+function loadConfig(configPath) {
+  if (!configPath) {
+    configPath = findConfigFile();
+  }
+  
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}`);
+  }
+  
+  const configContent = fs.readFileSync(configPath, 'utf8');
+  const config = yaml.load(configContent);
+
+  const { error, value } = configSchema.validate(config);
+  
+  if (error) {
+    throw new Error(`Invalid config: ${error.message}`);
+  }
+  
+  return value;
+}
+
 module.exports = { loadConfig };

package/src/dependency-resolver.js

@@ -1,102 +1,104 @@
-function resolveServiceExecutionGraph(config, presetName) {
-  const preset = config.presets[presetName];
-  if (!preset) {
-    throw new Error(`Preset '${presetName}' not found in configuration.`);
-  }
-
-  const services = [];
-  const dependencies = [];
-
-  for (const serviceName of preset.services) {
-    addService(
-      serviceName,
-      preset.modes[serviceName],
-      null,
-    );
-  }
-
-  return { dependencies, services };
-
-  function addService(serviceName, mode, dependentService) {
-    const service = config.services[serviceName];
-    if (service == null) {
-      throw new Error(`Service named '${serviceName}' not found in configuration.`);
-    }
-
-    if (dependentService != null) {
-      const existingService = services.find(({ name }) => {
-        return name === serviceName;
-      });
-      if (existingService != null) {
-        console.warn(
-          `Ignoring dependency '${serviceName}' for '${dependentService}' because it is flagged to be run as service in mode '${existingService.mode}'.`
-        );
-        return;
-      }
-    } else {
-      const existingDependencyIndex = dependencies.findIndex(({ name }) => {
-        return name === serviceName;
-      });
-      if (existingDependencyIndex >= 0) {
-        console.warn(
-          `Removing service '${serviceName}' from dependencies because it is flagged to be run as service in mode '${dependencies[existingDependencyIndex].mode}'.`
-        );
-        dependencies.splice(existingDependencyIndex, 1);
-      }
-    }
-
-    mode = (service.type === 'hybrid' ?
-      mode ?? service.defaultMode ?? 'dev' :
-      mode ?? 'dev'
-    );
-    const serviceConfig = (service.type === 'hybrid' ?
-      service.modes[mode] :
-      (mode === 'dev' ? service : undefined)
-    );
-
-    if (serviceConfig == null) {
-      throw new Error(`Mode named '${mode}' not found in service '${serviceName}'.`);
-    }
-
-    if (dependentService == null) {
-      services.push({
-        name: serviceName,
-        mode,
-        config: serviceConfig,
-      });
-    } else {
-      dependencies.unshift({
-        name: serviceName,
-        mode,
-        config: serviceConfig,
-      });
-    }
-
-    for (let index = serviceConfig.dependencies.length - 1; index >= 0; index--) {
-      const dependency = serviceConfig.dependencies[index];
-      const {
-        service: dependencyName,
-        mode: dependencyMode,
-      } = (typeof dependency === 'string' ?
-        { service: dependency, mode: 'dev' } :
-        dependency
-      );
-
-      const existingDependencyIndex = dependencies.find(({ name }) => {
-        return name === dependencyName;
-      });
-      if (existingDependencyIndex != null) {
-        console.warn(`Skipping dependency '${dependencyName}' for '${serviceName}' because it's already present in dependencies list.`);
-        continue;
-      }
-
-      addService(
-        dependencyName,
-        dependencyMode,
-        serviceName,
-      );
-    }
-  }
-}
-
+const log = require('./logger');
+
+function resolveServiceExecutionGraph(config, presetName) {
+  const preset = config.presets[presetName];
+  if (!preset) {
+    throw new Error(`Preset '${presetName}' not found in configuration.`);
+  }
+
+  const services = [];
+  const dependencies = [];
+
+  for (const serviceName of preset.services) {
+    addService(
+      serviceName,
+      preset.modes[serviceName],
+      null,
+    );
+  }
+
+  return { dependencies, services };
+
+  function addService(serviceName, mode, dependentService) {
+    const service = config.services[serviceName];
+    if (service == null) {
+      throw new Error(`Service named '${serviceName}' not found in configuration.`);
+    }
+
+    if (dependentService != null) {
+      const existingService = services.find(({ name }) => {
+        return name === serviceName;
+      });
+      if (existingService != null) {
+        log.warn(
+          `Ignoring dependency '${serviceName}' for '${dependentService}' because it is flagged to be run as service in mode '${existingService.mode}'.`
+        );
+        return;
+      }
+    } else {
+      const existingDependencyIndex = dependencies.findIndex(({ name }) => {
+        return name === serviceName;
+      });
+      if (existingDependencyIndex >= 0) {
+        log.warn(
+          `Removing service '${serviceName}' from dependencies because it is flagged to be run as service in mode '${dependencies[existingDependencyIndex].mode}'.`
+        );
+        dependencies.splice(existingDependencyIndex, 1);
+      }
+    }
+
+    mode = (service.type === 'hybrid' ?
+      mode ?? service.defaultMode ?? 'dev' :
+      mode ?? 'dev'
+    );
+    const serviceConfig = (service.type === 'hybrid' ?
+      service.modes[mode] :
+      (mode === 'dev' ? service : undefined)
+    );
+
+    if (serviceConfig == null) {
+      throw new Error(`Mode named '${mode}' not found in service '${serviceName}'.`);
+    }
+
+    if (dependentService == null) {
+      services.push({
+        name: serviceName,
+        mode,
+        config: serviceConfig,
+      });
+    } else {
+      dependencies.unshift({
+        name: serviceName,
+        mode,
+        config: serviceConfig,
+      });
+    }
+
+    for (let index = serviceConfig.dependencies.length - 1; index >= 0; index--) {
+      const dependency = serviceConfig.dependencies[index];
+      const {
+        service: dependencyName,
+        mode: dependencyMode,
+      } = (typeof dependency === 'string' ?
+        { service: dependency, mode: 'dev' } :
+        dependency
+      );
+
+      const existingDependencyIndex = dependencies.find(({ name }) => {
+        return name === dependencyName;
+      });
+      if (existingDependencyIndex != null) {
+        log.warn(`Skipping dependency '${dependencyName}' for '${serviceName}' because it's already present in dependencies list.`);
+        continue;
+      }
+
+      addService(
+        dependencyName,
+        dependencyMode,
+        serviceName,
+      );
+    }
+  }
+}
+
 module.exports = { resolveServiceExecutionGraph };

package/src/index.js

@@ -1,4 +1,9 @@
-const Orchestrator = require('./orchestrator');
-
-const orchestrator = new Orchestrator();
-orchestrator.start(process.argv[2]);
+const Orchestrator = require('./orchestrator');
+const { parseCliArgs } = require('./cli-args');
+
+const { presetName, configPath, logLevel, remaining } = parseCliArgs(process.argv.slice(2));
+
+process.argv = [process.argv[0], process.argv[1], presetName, ...remaining];
+
+const orchestrator = new Orchestrator(configPath, { logLevel });
+orchestrator.start(presetName);

package/src/logger.js

@@ -0,0 +1,47 @@
+const LEVELS = Object.freeze({
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+});
+
+let currentLevel = LEVELS.info;
+
+function setLogLevel(name) {
+  if (!Object.prototype.hasOwnProperty.call(LEVELS, name)) {
+    throw new Error(
+      `Unknown log level '${name}'. Expected one of: ${Object.keys(LEVELS).join(', ')}.`,
+    );
+  }
+  currentLevel = LEVELS[name];
+}
+
+function getLogLevel() {
+  return Object.keys(LEVELS).find(name => LEVELS[name] === currentLevel);
+}
+
+function error(...args) {
+  if (currentLevel >= LEVELS.error) console.error(...args);
+}
+
+function warn(...args) {
+  if (currentLevel >= LEVELS.warn) console.warn(...args);
+}
+
+function info(...args) {
+  if (currentLevel >= LEVELS.info) console.log(...args);
+}
+
+function debug(...args) {
+  if (currentLevel >= LEVELS.debug) console.log(...args);
+}
+
+module.exports = {
+  LEVELS,
+  setLogLevel,
+  getLogLevel,
+  error,
+  warn,
+  info,
+  debug,
+};