go-dev 0.6.0 → 0.8.0

package/src/cli-args.js

@@ -5,18 +5,20 @@
  *   <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>
+ *   -i,         --interactive                   — force the interactive TUI even when a preset is given
  *
  * 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[] }}
+ * @returns {{ presetName?: string, configPath?: string, logLevel?: string, interactive: boolean, remaining: string[] }}
  */
 function parseCliArgs(argv) {
   let presetName;
   let configPath;
   let logLevel;
+  let interactive = false;
   const remaining = [];
 
   let i = 0;
@@ -65,6 +67,11 @@ function parseCliArgs(argv) {
       continue;
     }
 
+    if (arg === '-i' || arg === '--interactive') {
+      interactive = true;
+      continue;
+    }
+
     if (presetName == null && !arg.startsWith('-')) {
       presetName = arg;
       continue;
@@ -77,7 +84,7 @@ function parseCliArgs(argv) {
     remaining.push(argv[i]);
   }
 
-  return { presetName, configPath, logLevel, remaining };
+  return { presetName, configPath, logLevel, interactive, remaining };
 }
 
 module.exports = { parseCliArgs };

package/src/config.js

@@ -141,4 +141,4 @@ function loadConfig(configPath) {
   return value;
 }
 
-module.exports = { loadConfig };
+module.exports = { loadConfig, findConfigFile };

package/src/dependency-resolver.js

@@ -1,55 +1,72 @@
-const log = require('./logger');
-
-function resolveServiceExecutionGraph(config, presetName) {
+/**
+ * Resolves a named preset to its `{ services, modes }` selection object,
+ * throwing if it does not exist. This is the single place that maps a preset
+ * name to data — everything downstream operates on the selection object, so a
+ * preset is just one way (alongside the interactive TUI) to produce one.
+ *
+ * @param {object} config
+ * @param {string} presetName
+ * @returns {{ services: string[], modes: Record<string, string> }}
+ */
+function resolvePreset(config, presetName) {
   const preset = config.presets[presetName];
   if (!preset) {
     throw new Error(`Preset '${presetName}' not found in configuration.`);
   }
+  return preset;
+}
+
+/**
+ * @param {object} config
+ * @param {{ services: string[], modes?: Record<string, string> }} selection
+ *   A service selection — same shape as a preset. May come from a preset
+ *   (via {@link resolvePreset}) or be built interactively.
+ * @returns {{
+ *   services: { name: string, mode: string, config: object }[],
+ *   dependencies: { name: string, mode: string, config: object, requiredBy: string }[],
+ *   conflicts: { service: string, requests: { mode: string, by: string | null }[] }[]
+ * }} `conflicts` lists services pulled in under more than one mode (e.g. one as
+ *   a primary and another as a dependency). go-dev runs one instance per
+ *   service name, so a conflicting selection leaves some dependency unmet.
+ */
+function resolveServiceExecutionGraph(config, selection) {
+  const modes = selection.modes ?? {};
 
   const services = [];
   const dependencies = [];
+  // serviceName -> Map<mode, requestedBy|null> — every mode a service is asked
+  // to run in, regardless of which instance actually wins the dedup below.
+  const requests = new Map();
 
-  for (const serviceName of preset.services) {
+  for (const serviceName of selection.services) {
     addService(
       serviceName,
-      preset.modes[serviceName],
+      modes[serviceName],
       null,
     );
   }
 
-  return { dependencies, services };
+  const conflicts = [];
+  for (const [service, byMode] of requests) {
+    if (byMode.size > 1) {
+      conflicts.push({
+        service,
+        requests: [...byMode].map(([mode, by]) => ({ mode, by })),
+      });
+    }
+  }
+
+  return { dependencies, services, conflicts };
 
-  function addService(serviceName, mode, dependentService) {
+  function addService(serviceName, requestedMode, 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 mode = (service.type === 'hybrid' ?
+      requestedMode ?? service.defaultMode ?? 'dev' :
+      requestedMode ?? 'dev'
     );
     const serviceConfig = (service.type === 'hybrid' ?
       service.modes[mode] :
@@ -60,18 +77,29 @@ function resolveServiceExecutionGraph(config, presetName) {
       throw new Error(`Mode named '${mode}' not found in service '${serviceName}'.`);
     }
 
-    if (dependentService == null) {
-      services.push({
-        name: serviceName,
-        mode,
-        config: serviceConfig,
-      });
+    // Record the requested mode so conflicting selections can be flagged later,
+    // even for the instance that loses the dedup below.
+    let requested = requests.get(serviceName);
+    if (!requested) {
+      requests.set(serviceName, requested = new Map());
+    }
+    if (!requested.has(mode)) {
+      requested.set(mode, dependentService ?? null);
+    }
+
+    if (dependentService != null) {
+      // One instance per service name: if it's already scheduled (as a primary
+      // or another dependency), keep the first. Mode mismatches surface via
+      // `conflicts`, not by silently swapping the running mode.
+      if (services.some(({ name }) => name === serviceName)) return;
+      if (dependencies.some(({ name }) => name === serviceName)) return;
+      dependencies.unshift({ name: serviceName, mode, config: serviceConfig, requiredBy: dependentService });
     } else {
-      dependencies.unshift({
-        name: serviceName,
-        mode,
-        config: serviceConfig,
-      });
+      const existingDependencyIndex = dependencies.findIndex(({ name }) => name === serviceName);
+      if (existingDependencyIndex >= 0) {
+        dependencies.splice(existingDependencyIndex, 1); // promote dependency -> primary
+      }
+      services.push({ name: serviceName, mode, config: serviceConfig });
     }
 
     for (let index = serviceConfig.dependencies.length - 1; index >= 0; index--) {
@@ -84,14 +112,6 @@ function resolveServiceExecutionGraph(config, presetName) {
         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,
@@ -101,4 +121,4 @@ function resolveServiceExecutionGraph(config, presetName) {
   }
 }
 
-module.exports = { resolveServiceExecutionGraph };
+module.exports = { resolveServiceExecutionGraph, resolvePreset };

package/src/index.js

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

package/src/interactive.js

@@ -0,0 +1,342 @@
+const termkit = require('terminal-kit');
+const { savePreset } = require('./save-preset');
+const { resolveServiceExecutionGraph } = require('./dependency-resolver');
+const { loadLastSelection } = require('./last-selection');
+const log = require('./logger');
+
+/**
+ * Full-screen interactive selection TUI (terminal-kit).
+ *
+ * Two tabs — "Presets" and "Services & Modes" — let the user either launch an
+ * existing preset or compose a custom selection (toggle services, pick a mode
+ * for hybrid services), optionally saving it back as a new preset.
+ *
+ * Runs to completion *before* the orchestrator takes over stdout, then fully
+ * restores the terminal. Resolves to a selection `{ name?, services, modes }`,
+ * or `null` if the user cancels (q / Esc / Ctrl+C).
+ *
+ * @param {object} config - the loaded, validated go-dev config.
+ * @param {{ configPath: string, presetName?: string }} options
+ * @returns {Promise<{ name?: string, services: string[], modes: Record<string,string> } | null>}
+ */
+function runInteractive(config, { configPath, presetName } = {}) {
+  const term = termkit.terminal;
+  const serviceNames = Object.keys(config.services ?? {});
+  const presetNames = Object.keys(config.presets ?? {});
+
+  const isHybrid = (name) => config.services[name].type === 'hybrid';
+  const modesFor = (name) => (isHybrid(name) ? Object.keys(config.services[name].modes) : ['dev']);
+  const defaultModeFor = (name) =>
+    isHybrid(name)
+      ? config.services[name].defaultMode ?? modesFor(name)[0] ?? 'dev'
+      : 'dev';
+
+  // --- state ---------------------------------------------------------------
+  const selected = new Set();
+  const chosenMode = new Map();
+  for (const name of serviceNames) chosenMode.set(name, defaultModeFor(name));
+
+  // Pre-populate the custom selection: from a preset when forced interactive
+  // with one, otherwise restore the last launched selection (dropping anything
+  // no longer valid in the current config).
+  if (presetName && config.presets?.[presetName]) {
+    const preset = config.presets[presetName];
+    for (const s of preset.services) selected.add(s);
+    for (const [s, m] of Object.entries(preset.modes ?? {})) chosenMode.set(s, m);
+  } else {
+    const last = loadLastSelection(configPath);
+    if (last) {
+      for (const s of last.services) {
+        if (serviceNames.includes(s)) selected.add(s);
+      }
+      for (const [s, m] of Object.entries(last.modes ?? {})) {
+        if (serviceNames.includes(s) && modesFor(s).includes(m)) chosenMode.set(s, m);
+      }
+    }
+  }
+
+  const TABS = ['Services & Modes', 'Presets'];
+  let activeTab = 0; // land on Services & Modes; Tab switches to Presets
+  let cursor = 0;
+  let message = '';
+
+  // --- rendering -----------------------------------------------------------
+  function drawHeader() {
+    term.moveTo(1, 1).styleReset().bold('go-dev')(' — selezione servizi');
+    term.moveTo(1, 2);
+    TABS.forEach((label, i) => {
+      if (i === activeTab) term.bgBrightWhite.black(` ${label} `);
+      else term.bgGray.white(` ${label} `);
+      term('  ');
+    });
+  }
+
+  function drawPresets() {
+    term.moveTo(1, 4)('Preset disponibili — ↑/↓ scegli, invio avvia:');
+    if (presetNames.length === 0) {
+      term.moveTo(3, 6).gray('(nessun preset definito — usa la tab Services & Modes)');
+      return;
+    }
+    presetNames.forEach((name, i) => {
+      const marker = i === cursor ? '❯' : ' ';
+      const services = (config.presets[name].services ?? []).join(', ');
+      term.moveTo(2, 6 + i);
+      const text = `${marker} ${name}`;
+      if (i === cursor) term.brightCyan(text);
+      else term(text);
+      term.gray(`   services: ${services}`);
+    });
+  }
+
+  function drawServices() {
+    term.moveTo(1, 4)('Servizi — spazio: on/off, m: modalità, invio: avvia:');
+    if (serviceNames.length === 0) {
+      term.moveTo(3, 6).gray('(nessun servizio definito)');
+      return;
+    }
+    serviceNames.forEach((name, i) => {
+      const marker = i === cursor ? '❯' : ' ';
+      const box = selected.has(name) ? '[x]' : '[ ]';
+      term.moveTo(2, 6 + i);
+      const text = `${marker} ${box} ${name}`;
+      if (i === cursor) term.brightCyan(text);
+      else term(text);
+      const mode = isHybrid(name) ? chosenMode.get(name) : 'dev';
+      term.gray(`   mode: ${mode}${isHybrid(name) ? ' (m per cambiare)' : ''}`);
+    });
+  }
+
+  // Selection the bottom panel previews. On the Services tab it reflects the
+  // *checked* services (not the cursor); on the Presets tab, the highlighted preset.
+  function panelSelection() {
+    if (activeTab === 0) {
+      const services = serviceNames.filter((s) => selected.has(s));
+      const modes = {};
+      for (const s of services) {
+        if (isHybrid(s)) modes[s] = chosenMode.get(s);
+      }
+      return { services, modes };
+    }
+    const preset = presetNames[cursor];
+    if (!preset) return null;
+    return { services: config.presets[preset].services, modes: config.presets[preset].modes ?? {} };
+  }
+
+  // Bottom panel: the resolved selection split into labelled sections.
+  function drawPanel(top) {
+    term.moveTo(1, top).styleReset().gray('─'.repeat(Math.min(term.width, 64)));
+
+    const selection = panelSelection();
+    if (!selection) return;
+
+    let graph;
+    const previousLevel = log.getLogLevel();
+    try {
+      log.setLogLevel('error'); // silence resolver dedup warnings while previewing
+      graph = resolveServiceExecutionGraph(config, selection);
+    } catch (error) {
+      term.moveTo(3, top + 1).styleReset().red(`⚠ ${error.message}`);
+      return;
+    } finally {
+      log.setLogLevel(previousLevel);
+    }
+
+    let row = top + 1;
+    const header = (label) => {
+      if (row >= term.height - 1) return;
+      term.moveTo(1, row++).styleReset().bold(label);
+    };
+    const item = (label, style) => {
+      if (row >= term.height - 1) return;
+      term.moveTo(3, row++).styleReset();
+      style(label);
+    };
+    const blank = () => { row++; };
+
+    header('servizi principali');
+    if (graph.services.length) {
+      graph.services.forEach((s) => item(`${s.name}:${s.mode}`, (t) => term.brightWhite(t)));
+    } else {
+      item(activeTab === 0 ? '(nessun servizio selezionato)' : '(nessuno)', (t) => term.gray(t));
+    }
+
+    blank();
+    header('dipendenze');
+    if (graph.dependencies.length) {
+      graph.dependencies.forEach((d) => item(`${d.name}:${d.mode}`, (t) => term.white(t)));
+    } else {
+      item('(nessuna)', (t) => term.gray(t));
+    }
+
+    if (graph.conflicts.length) {
+      blank();
+      if (row < term.height - 1) term.moveTo(1, row++).styleReset().red('⚠ conflitti di modalità');
+      for (const { service, requests } of graph.conflicts) {
+        const where = requests
+          .map((r) => `${r.mode}${r.by ? ` (dip. di ${r.by})` : ' (primario)'}`)
+          .join(' vs ');
+        item(`${service}: ${where}`, (t) => term.yellow(t));
+      }
+      item('un solo avvio per servizio — alcune dipendenze restano non soddisfatte', (t) => term.gray(t));
+    }
+  }
+
+  function render() {
+    term.clear();
+    drawHeader();
+    if (activeTab === 0) drawServices();
+    else drawPresets();
+
+    const panelTop = 6 + Math.max(serviceNames.length, presetNames.length, 1) + 1;
+    drawPanel(panelTop);
+
+    if (message) {
+      term.moveTo(1, term.height - 1).styleReset().yellow(message);
+    }
+    term.moveTo(1, term.height).styleReset().gray(
+      ' ←/→ tab   ↑/↓ muovi   spazio on/off   m modalità   invio avvia   q esci'
+    );
+  }
+
+  // --- helpers -------------------------------------------------------------
+  function currentList() {
+    return activeTab === 0 ? serviceNames : presetNames;
+  }
+
+  function cycleMode(name) {
+    if (!isHybrid(name)) return;
+    const modes = modesFor(name);
+    const next = (modes.indexOf(chosenMode.get(name)) + 1) % modes.length;
+    chosenMode.set(name, modes[next]);
+  }
+
+  function buildCustomSelection() {
+    const services = serviceNames.filter((s) => selected.has(s));
+    const modes = {};
+    for (const s of services) {
+      if (isHybrid(s)) modes[s] = chosenMode.get(s);
+    }
+    return { name: undefined, services, modes };
+  }
+
+  // --- lifecycle -----------------------------------------------------------
+  return new Promise((resolve) => {
+    let finished = false;
+    let inPrompt = false; // true while terminal-kit's save prompts own the screen
+
+    function cleanup() {
+      term.removeListener('key', onKey);
+      term.removeListener('resize', onResize);
+      term.grabInput(false);
+      term.hideCursor(false);
+      term.fullscreen(false);
+    }
+
+    // terminal-kit updates term.width/term.height before emitting 'resize';
+    // render() recomputes its layout from those, so a full redraw is enough.
+    function onResize() {
+      if (finished || inPrompt) return;
+      render();
+    }
+
+    function finish(result) {
+      if (finished) return;
+      finished = true;
+      cleanup();
+      resolve(result);
+    }
+
+    async function confirmCustom() {
+      const selection = buildCustomSelection();
+      if (selection.services.length === 0) {
+        message = 'Seleziona almeno un servizio (spazio).';
+        return render();
+      }
+
+      // Hand input over to terminal-kit's prompt helpers for the save flow.
+      inPrompt = true;
+      term.removeListener('key', onKey);
+      term.hideCursor(false);
+
+      term.moveTo(1, term.height - 2).styleReset().eraseLine();
+      term('Salvare questa selezione come preset? [s/N] ');
+      const wantsSave = await term.yesOrNo({ yes: ['s', 'y'], no: ['n', 'ENTER', 'ESCAPE'] }).promise;
+
+      if (wantsSave) {
+        term.moveTo(1, term.height - 1).styleReset().eraseLine();
+        term('Nome del preset: ');
+        const name = ((await term.inputField().promise) || '').trim();
+        if (name) {
+          try {
+            savePreset(configPath, name, selection);
+            selection.name = name;
+          } catch (error) {
+            term.moveTo(1, term.height).styleReset().eraseLine().red(`Errore: ${error.message}`);
+            await term.yesOrNo({ yes: ['ENTER', 'y', 's'], no: ['n'] }).promise; // pausa per leggere
+          }
+        }
+      }
+
+      return finish(selection);
+    }
+
+    function onKey(name) {
+      message = '';
+
+      if (name === 'CTRL_C' || name === 'ESCAPE' || name === 'q') return finish(null);
+
+      if (name === 'TAB' || name === 'LEFT' || name === 'RIGHT') {
+        activeTab = (activeTab + 1) % TABS.length;
+        cursor = 0;
+        return render();
+      }
+
+      const list = currentList();
+      if (name === 'UP') {
+        cursor = list.length ? (cursor - 1 + list.length) % list.length : 0;
+        return render();
+      }
+      if (name === 'DOWN') {
+        cursor = list.length ? (cursor + 1) % list.length : 0;
+        return render();
+      }
+
+      if (activeTab === 1) {
+        // Presets tab
+        if (name === 'ENTER') {
+          const preset = presetNames[cursor];
+          if (!preset) return;
+          return finish({
+            name: preset,
+            services: config.presets[preset].services,
+            modes: config.presets[preset].modes ?? {},
+          });
+        }
+        return;
+      }
+
+      // Services & Modes tab
+      const svc = serviceNames[cursor];
+      if (!svc) return;
+      if (name === ' ' || name === 'SPACE') {
+        if (selected.has(svc)) selected.delete(svc);
+        else selected.add(svc);
+        return render();
+      }
+      if (name === 'm') {
+        cycleMode(svc);
+        return render();
+      }
+      if (name === 'ENTER') return confirmCustom();
+    }
+
+    term.fullscreen(true);
+    term.grabInput(true);
+    term.hideCursor(true);
+    term.on('key', onKey);
+    term.on('resize', onResize);
+    render();
+  });
+}
+
+module.exports = { runInteractive };

package/src/last-selection.js

@@ -0,0 +1,75 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Where we remember the last launched selection — a single per-user file,
+// keyed by config path, kept OUTSIDE the consumer's repo so it never shows up
+// in their working tree. Follows XDG state on Linux/macOS, LOCALAPPDATA on
+// Windows.
+function stateDir() {
+  if (process.platform === 'win32') {
+    const base = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    return path.join(base, 'go-dev');
+  }
+  const base = process.env.XDG_STATE_HOME || path.join(os.homedir(), '.local', 'state');
+  return path.join(base, 'go-dev');
+}
+
+function stateFile() {
+  return path.join(stateDir(), 'last-selections.json');
+}
+
+function readAll() {
+  try {
+    return JSON.parse(fs.readFileSync(stateFile(), 'utf8')) || {};
+  } catch {
+    return {}; // missing or corrupt — start fresh
+  }
+}
+
+// Key by the canonical absolute path of the config file, so the same file
+// reached via a relative path, a symlink, or `..` always maps to one entry.
+function keyFor(configPath) {
+  const absolute = path.resolve(configPath);
+  try {
+    return fs.realpathSync(absolute);
+  } catch {
+    return absolute; // file not resolvable (shouldn't happen for a loaded config)
+  }
+}
+
+/**
+ * Returns the last selection launched against this config, or null.
+ * @param {string} configPath
+ * @returns {{ name?: string, services: string[], modes: Record<string,string> } | null}
+ */
+function loadLastSelection(configPath) {
+  if (!configPath) return null;
+  const entry = readAll()[keyFor(configPath)];
+  if (!entry || !Array.isArray(entry.services)) return null;
+  return { name: entry.name, services: entry.services, modes: entry.modes ?? {} };
+}
+
+/**
+ * Persists the last launched selection for this config. Best-effort: never lets
+ * a persistence failure (e.g. read-only home) break a launch.
+ * @param {string} configPath
+ * @param {{ name?: string, services: string[], modes?: Record<string,string> }} selection
+ */
+function saveLastSelection(configPath, selection) {
+  if (!configPath || !selection) return;
+  try {
+    const all = readAll();
+    all[keyFor(configPath)] = {
+      name: selection.name,
+      services: selection.services,
+      modes: selection.modes ?? {},
+    };
+    fs.mkdirSync(stateDir(), { recursive: true });
+    fs.writeFileSync(stateFile(), JSON.stringify(all, null, 2), 'utf8');
+  } catch {
+    // ignore — remembering the selection is a convenience, not a requirement
+  }
+}
+
+module.exports = { loadLastSelection, saveLastSelection, stateFile };