go-dev 0.7.0 → 0.8.0

package/README.md

@@ -69,6 +69,8 @@ If the same service is pulled in under **two different modes** (e.g. `keplero:bu
 
 Navigate tabs with <kbd>←</kbd>/<kbd>→</kbd>, move with <kbd>↑</kbd>/<kbd>↓</kbd>, and quit with <kbd>q</kbd>. When stdin is not a TTY (e.g. CI) and no preset is given, `go-dev` exits with an error instead of opening the TUI.
 
+The selector **remembers your last launched selection per config file** and restores it the next time you open it. This state is stored in your user state directory (`$XDG_STATE_HOME/go-dev/` on Linux/macOS, `%LOCALAPPDATA%\go-dev\` on Windows), keyed by the config file's canonical absolute path — **never written into your repo**.
+
 **Passing Arguments to Service Commands:**
 
 To pass additional arguments from the command line to a specific service command, use a keyword flag followed by the target and its arguments.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "go-dev",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "main": "src/index.js",
   "bin": {
     "go-dev": "bin/go-dev"

package/src/interactive.js

@@ -1,6 +1,7 @@
 const termkit = require('terminal-kit');
 const { savePreset } = require('./save-preset');
 const { resolveServiceExecutionGraph } = require('./dependency-resolver');
+const { loadLastSelection } = require('./last-selection');
 const log = require('./logger');
 
 /**
@@ -35,11 +36,23 @@ function runInteractive(config, { configPath, presetName } = {}) {
   const chosenMode = new Map();
   for (const name of serviceNames) chosenMode.set(name, defaultModeFor(name));
 
-  // Pre-populate from a preset when forced interactive with a preset given.
+  // 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'];
@@ -209,14 +222,23 @@ function runInteractive(config, { configPath, presetName } = {}) {
   // --- 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;
@@ -232,6 +254,7 @@ function runInteractive(config, { configPath, presetName } = {}) {
       }
 
       // Hand input over to terminal-kit's prompt helpers for the save flow.
+      inPrompt = true;
       term.removeListener('key', onKey);
       term.hideCursor(false);
 
@@ -311,6 +334,7 @@ function runInteractive(config, { configPath, presetName } = {}) {
     term.grabInput(true);
     term.hideCursor(true);
     term.on('key', onKey);
+    term.on('resize', onResize);
     render();
   });
 }

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 };

package/src/run.js

@@ -3,6 +3,7 @@ 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');
 
 /**
@@ -41,6 +42,10 @@ async function run(argv) {
       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];