go-dev 0.6.0 → 0.8.0

package/src/orchestrator.js

@@ -16,6 +16,7 @@ const bold = (text) => `\x1b[1m${text}\x1b[0m`;
 
 class Orchestrator {
   constructor(configPath, options = {}) {
+    this.configPath = configPath;
     this.config = loadConfig(configPath);
 
     const level = options.logLevel ?? this.config.logLevel;
@@ -29,19 +30,34 @@ class Orchestrator {
     BaseService.initialize(this.processManager, this.config.services);
   }
 
-  async start(presetName) {
+  /**
+   * @param {{ name?: string, services: string[], modes?: Record<string, string> }} selection
+   *   The service selection to run — from a preset or built interactively.
+   */
+  async start(selection) {
     try {
-      const { dependencies, services: primaryServices } = resolveServiceExecutionGraph(
+      const { dependencies, services: primaryServices, conflicts } = resolveServiceExecutionGraph(
         this.config,
-        presetName,
+        selection,
       );
 
-      log.info(bold(`Preset: ${presetName}`));
+      log.info(bold(`Preset: ${selection.name ?? 'selezione personalizzata'}`));
       log.info(`\n${bold('Resolved dependencies')}`);
       dependencies.forEach(s => log.info(` - ${colorService(s.name, s.mode)} (mode: ${colorMode(s.name, s.mode)})`));
       log.info(`\n${bold('Resolved primary services')}`);
       primaryServices.forEach(s => log.info(` - ${colorService(s.name, s.mode)} (mode: ${colorMode(s.name, s.mode)})`));
 
+      if (conflicts.length > 0) {
+        log.warn(`\n${bold('⚠ Mode conflicts')}`);
+        for (const { service, requests } of conflicts) {
+          const where = requests
+            .map(r => `${colorMode(service, r.mode)}${r.by ? ` (dep of ${r.by})` : ' (primary)'}`)
+            .join(' vs ');
+          log.warn(` - '${service}' requested in conflicting modes: ${where}.`);
+        }
+        log.warn(`   go-dev runs one instance per service, so some dependencies above may be unmet.`);
+      }
+
       const extraArgs = new Map();
       {
         const argsToParse = process.argv.slice(3);
@@ -61,7 +77,7 @@ class Orchestrator {
             }
             if (currentService == null) {
               if (isGettingService === false) {
-                throw new Error(`Invalid arguments, use format: npx go-dev ${presetName} ${serviceArgsKeyword} <service> <args>`);
+                throw new Error(`Invalid arguments, use format: npx go-dev ${selection.name ?? '<preset>'} ${serviceArgsKeyword} <service> <args>`);
               }
 
               const splitArg = arg.split(':');

package/src/run.js

@@ -0,0 +1,62 @@
+const Orchestrator = require('./orchestrator');
+const { parseCliArgs } = require('./cli-args');
+const { findConfigFile } = require('./config');
+const { resolvePreset } = require('./dependency-resolver');
+const { runInteractive } = require('./interactive');
+const { saveLastSelection } = require('./last-selection');
+const log = require('./logger');
+
+/**
+ * Shared CLI entry flow, used by both `bin/go-dev` and `src/index.js`.
+ *
+ * Resolves a service selection — from a preset name, or interactively when no
+ * preset is given (or `--interactive` is set) — and hands it to the orchestrator.
+ *
+ * @param {string[]} argv - argv tail (already stripped of node + script path).
+ */
+async function run(argv) {
+  try {
+    const { presetName, configPath, logLevel, interactive, remaining } = parseCliArgs(argv);
+
+    const resolvedConfigPath = configPath ?? findConfigFile();
+    const orchestrator = new Orchestrator(resolvedConfigPath, { logLevel });
+
+    let selection;
+    if (interactive || !presetName) {
+      if (!presetName && !process.stdin.isTTY) {
+        console.error(
+          'Error: no preset given and no interactive terminal. ' +
+          'Specify a preset (go-dev <preset>) or run in a TTY to use the interactive selector.'
+        );
+        process.exit(1);
+      }
+
+      selection = await runInteractive(orchestrator.config, {
+        configPath: resolvedConfigPath,
+        presetName,
+      });
+      if (!selection) {
+        process.exit(0); // user cancelled
+      }
+    } else {
+      selection = { name: presetName, ...resolvePreset(orchestrator.config, presetName) };
+    }
+
+    // Remember this selection (per config, in the user's state dir — never in
+    // the consumer's repo) so the interactive selector can restore it next time.
+    saveLastSelection(resolvedConfigPath, selection);
+
+    // Keep `remaining` (the `--args-for ...` tail) at argv index >= 3, where the
+    // orchestrator's per-service args parser reads it. Index 2 is unused there.
+    process.argv = [process.argv[0], process.argv[1], selection.name ?? '', ...remaining];
+
+    await orchestrator.start(selection);
+  } catch (error) {
+    // Setup-phase failures (bad config, unknown preset, TUI errors). The
+    // orchestrator handles its own runtime errors and cleanup internally.
+    log.error(`\n❌ ${error.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { run };

package/src/save-preset.js

@@ -0,0 +1,103 @@
+const fs = require('fs');
+const yaml = require('js-yaml');
+const { loadConfig } = require('./config');
+
+/**
+ * Renders a value as a YAML scalar, quoting it only when it isn't a plain,
+ * safe identifier. Service/mode names come from config keys (already safe);
+ * user-typed preset names may need quoting.
+ */
+function scalar(value) {
+  return /^[A-Za-z0-9_][A-Za-z0-9_.-]*$/.test(value) ? value : JSON.stringify(value);
+}
+
+/**
+ * Builds the YAML block for a single preset entry, indented under `presets:`.
+ *
+ * @param {string} name
+ * @param {{ services: string[], modes?: Record<string, string> }} selection
+ * @param {string} indent - leading indentation for the entry key (e.g. '  ').
+ */
+function buildPresetBlock(name, selection, indent) {
+  const step = '  ';
+  const lines = [
+    `${indent}${scalar(name)}:`,
+    `${indent}${step}services: [${selection.services.map(scalar).join(', ')}]`,
+  ];
+
+  const modes = selection.modes ?? {};
+  const modeEntries = Object.entries(modes).filter(([, mode]) => mode != null);
+  if (modeEntries.length > 0) {
+    lines.push(`${indent}${step}modes:`);
+    for (const [service, mode] of modeEntries) {
+      lines.push(`${indent}${step}${step}${scalar(service)}: ${scalar(mode)}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Inserts a preset into a raw YAML config, preserving the rest of the file
+ * (comments, key order, formatting). Falls back to a full re-dump only when the
+ * existing `presets:` key isn't a plain block we can append to.
+ *
+ * @param {string} raw
+ * @param {string} name
+ * @param {object} selection
+ * @returns {string} the new file content
+ */
+function insertPreset(raw, name, selection) {
+  const lines = raw.split('\n');
+  const presetsIndex = lines.findIndex((line) => /^(\s*)presets:\s*$/.test(line));
+
+  // Case A: a plain `presets:` block key exists — insert as its first entry.
+  if (presetsIndex >= 0) {
+    const baseIndent = lines[presetsIndex].match(/^(\s*)/)[1] + '  ';
+    const block = buildPresetBlock(name, selection, baseIndent);
+    lines.splice(presetsIndex + 1, 0, block);
+    return lines.join('\n');
+  }
+
+  // Case B: no `presets:` key at all — append a fresh block at the end.
+  const hasPresetsKey = lines.some((line) => /^\s*presets:/.test(line));
+  if (!hasPresetsKey) {
+    const trimmed = raw.replace(/\s*$/, '');
+    const block = buildPresetBlock(name, selection, '  ');
+    return `${trimmed}\n\npresets:\n${block}\n`;
+  }
+
+  // Case C: `presets:` exists but inline (e.g. `presets: {}`) — re-dump to stay
+  // structurally correct. Comments are lost; acceptable for this edge case.
+  const parsed = yaml.load(raw) ?? {};
+  parsed.presets = parsed.presets ?? {};
+  parsed.presets[name] = {
+    services: selection.services,
+    ...(Object.keys(selection.modes ?? {}).length > 0 ? { modes: selection.modes } : {}),
+  };
+  return yaml.dump(parsed, { lineWidth: 120 });
+}
+
+/**
+ * Persists a selection as a named preset in the given config file, then
+ * re-validates the file by loading it. On validation failure the original
+ * content is restored and the error is re-thrown.
+ *
+ * @param {string} configPath
+ * @param {string} name
+ * @param {{ services: string[], modes?: Record<string, string> }} selection
+ */
+function savePreset(configPath, name, selection) {
+  const original = fs.readFileSync(configPath, 'utf8');
+  const updated = insertPreset(original, name, selection);
+
+  fs.writeFileSync(configPath, updated, 'utf8');
+  try {
+    loadConfig(configPath);
+  } catch (error) {
+    fs.writeFileSync(configPath, original, 'utf8');
+    throw new Error(`Failed to save preset '${name}': ${error.message}`);
+  }
+}
+
+module.exports = { savePreset, insertPreset };