agy-powerline 1.2.0 → 1.3.0

package/src/cli/import.js

@@ -0,0 +1,273 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const {
+  saveConfig,
+  setConfigDir,
+  getConfigPath,
+  mergeConfig,
+  renderStatusline,
+  sampleData,
+  detectStyle,
+} = require("../lib/shared");
+const { resolveInstallDir, writeFileAtomic, PRIVATE_FILE_MODE } = require("../lib/paths");
+const { createRl, confirm } = require("../lib/prompt");
+const { loadEditableConfig } = require("./config-guard");
+const { version } = require("../../package.json");
+
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const GREEN = "\x1b[32m";
+const RED = "\x1b[31m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const RESET = "\x1b[0m";
+
+// A config is a few KB; anything this big isn't one.
+const MAX_IMPORT_BYTES = 256 * 1024;
+const BACKUP_SUFFIX = ".bak";
+const { visible, droppedSettings } = require("../lib/config-check");
+const SETTINGS = ["emojis", "ascii", "color", "pacing", "minimalist", "rowGap", "log"];
+
+function readImportFile(file) {
+  const target = path.resolve(String(file));
+  let stat;
+  try {
+    stat = fs.statSync(target);
+  } catch {
+    return { target, error: "the file doesn't exist" };
+  }
+  if (!stat.isFile()) {
+    return { target, error: "it isn't a file" };
+  }
+  if (stat.size > MAX_IMPORT_BYTES) {
+    return {
+      target,
+      error: `it is larger than ${MAX_IMPORT_BYTES / 1024} KB, so it isn't a config`,
+    };
+  }
+
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(target, "utf8").replace(/^\uFEFF/, ""));
+  } catch (err) {
+    // The parser quotes the text it failed on; keep only where.
+    const at = String(err.message).match(/position \d+|line \d+ column \d+/)?.[0];
+    return { target, error: `it isn't valid JSON${at ? ` (${at})` : ""}` };
+  }
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return { target, error: "its top-level value isn't an object" };
+  }
+  return { target, data };
+}
+
+function majorOf(value) {
+  const major = parseInt(String(value ?? "").match(/^(\d+)\./)?.[1] ?? "", 10);
+  return Number.isFinite(major) ? major : null;
+}
+
+// "model context git / fiveHourBar fiveHourReset ...", one row per line break.
+function widgetRows(widgets) {
+  const rows = [[]];
+  for (const widget of widgets) {
+    if (widget.id === "lineBreak") {
+      rows.push([]);
+    } else if (widget.id !== "separator") {
+      rows[rows.length - 1].push(widget.id);
+    }
+  }
+  return rows.map((row) => row.join(" ") || "(empty row)");
+}
+
+function changes(before, after) {
+  const lines = [];
+  const show = (value) => (value === undefined || value === null ? "off" : JSON.stringify(value));
+  const compare = (name, a, b) => {
+    if (JSON.stringify(a) !== JSON.stringify(b)) {
+      lines.push(`  ${name.padEnd(11)} ${DIM}${visible(show(a))}${RESET} → ${visible(show(b))}`);
+    }
+  };
+
+  compare("theme", before.theme, after.theme);
+  compare("layout", before.layout, after.layout);
+  compare(
+    "style",
+    detectStyle(before.powerline) ?? "custom",
+    detectStyle(after.powerline) ?? "custom"
+  );
+  compare("gradient", before.gradient, after.gradient);
+  compare("meterStyle", before.meterStyle, after.meterStyle);
+  for (const key of SETTINGS) {
+    compare(key, before[key], after[key]);
+  }
+  compare("thresholds", before.thresholds, after.thresholds);
+  compare("clock", before.clock, after.clock);
+  compare("customTheme", before.customTheme, after.customTheme);
+
+  const rowsBefore = widgetRows(before.widgets);
+  const rowsAfter = widgetRows(after.widgets);
+  if (JSON.stringify(before.widgets) !== JSON.stringify(after.widgets)) {
+    lines.push("  widgets");
+    rowsBefore.forEach((row) => lines.push(`    ${DIM}- ${visible(row)}${RESET}`));
+    rowsAfter.forEach((row) => lines.push(`    + ${visible(row)}`));
+    if (JSON.stringify(rowsBefore) === JSON.stringify(rowsAfter)) {
+      lines.push(`    ${DIM}(same widgets, different options)${RESET}`);
+    }
+  }
+  return lines;
+}
+
+// Exec commands the import would add: these run on every refresh.
+function newCommands(before, after) {
+  const known = new Set(
+    before.widgets.filter((widget) => widget.id === "exec").map((widget) => String(widget.cmd))
+  );
+  return after.widgets
+    .filter((widget) => widget.id === "exec" && String(widget.cmd || "").trim())
+    .map((widget) => String(widget.cmd))
+    .filter((cmd) => !known.has(cmd));
+}
+
+function fail(message, hint) {
+  console.error(`${RED}error${RESET} ${message}`);
+  if (hint) {
+    console.error(` ${hint}`);
+  }
+  process.exitCode = 1;
+}
+
+async function importCommand(file, options = {}) {
+  if (!file) {
+    fail("Name the file to import.", "Usage: npx agy-powerline import <file> [--merge] [--yes]");
+    return;
+  }
+
+  const installDir = resolveInstallDir();
+  if (!installDir) {
+    return;
+  }
+  setConfigDir(installDir);
+  // A broken config is never replaced: the user can still fix it.
+  const current = loadEditableConfig();
+  if (!current) {
+    return;
+  }
+
+  const { target, data, error } = readImportFile(file);
+  if (error) {
+    fail(`Can't import ${target}: ${error}. Nothing was changed.`);
+    return;
+  }
+
+  const { agyPowerline, ...raw } = data;
+  const fileMajor = majorOf(agyPowerline?.version);
+  if (fileMajor !== null && fileMajor > majorOf(version)) {
+    fail(
+      `${target} comes from agy-powerline ${visible(agyPowerline.version)}, newer than this one (${version}). Nothing was changed.`,
+      "Update first: npx agy-powerline@latest import <file>"
+    );
+    return;
+  }
+
+  const merge = Boolean(options.merge);
+  const next = mergeConfig(merge ? { ...current, ...raw } : raw);
+
+  console.log();
+  console.log(`${BOLD} Import ${RESET}${DIM}${target}${RESET} ${merge ? "(merge)" : "(replace)"}`);
+  const dropped = droppedSettings(raw);
+  if (dropped.length) {
+    console.log(`${YELLOW} Left out${RESET} (this version can't use them):`);
+    dropped.forEach((item) => console.log(`  ${item}`));
+  }
+
+  const diff = changes(current, next);
+  if (!diff.length) {
+    console.log(" Nothing to change: the file matches your config.");
+    console.log();
+    return;
+  }
+  console.log(" Changes:");
+  diff.forEach((line) => console.log(line));
+  console.log();
+  console.log(" Preview:");
+  console.log(renderStatusline(sampleData(), next));
+  console.log();
+
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const added = newCommands(current, next);
+  const rl =
+    interactive && (!options.yes || (added.length && !options["allow-exec"])) ? createRl() : null;
+
+  try {
+    if (added.length) {
+      console.log(
+        `${YELLOW} The file adds ${added.length} shell command${added.length === 1 ? "" : "s"}${RESET}, run on every refresh:`
+      );
+      added.forEach((cmd) => console.log(`  ${CYAN}${visible(cmd)}${RESET}`));
+      console.log();
+      if (!options["allow-exec"]) {
+        if (!rl) {
+          fail(
+            "The file adds shell commands. Nothing was changed.",
+            "Check them above, then pass --allow-exec to import them."
+          );
+          return;
+        }
+        if (!(await confirm(rl, "Run these commands in your bar?", false))) {
+          console.log(" Nothing was changed.");
+          return;
+        }
+      }
+    }
+
+    if (!options.yes) {
+      if (!rl) {
+        fail("No TTY. Pass --yes to import non-interactively. Nothing was changed.");
+        return;
+      }
+      if (!(await confirm(rl, "Apply this config?", false))) {
+        console.log(" Nothing was changed.");
+        return;
+      }
+    }
+  } finally {
+    rl?.close();
+  }
+
+  // One import can be undone by importing the backup.
+  const configPath = getConfigPath();
+  const backup = `${configPath}${BACKUP_SUFFIX}`;
+  let backedUp = false;
+  try {
+    const previous = fs.readFileSync(configPath, "utf8");
+    writeFileAtomic(backup, previous, { mode: PRIVATE_FILE_MODE });
+    backedUp = true;
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      fail(`Can't back up ${configPath} (${err.code || "error"}). Nothing was changed.`);
+      return;
+    }
+  }
+
+  saveConfig(next);
+
+  console.log(`${GREEN}✔${RESET} Config imported into ${DIM}${configPath}${RESET}`);
+  if (backedUp) {
+    console.log(
+      `  previous config  ${DIM}${backup}${RESET} (undo: npx agy-powerline import "${backup}")`
+    );
+  }
+  console.log(" The bar shows it on its next refresh.");
+  console.log();
+}
+
+module.exports = {
+  importCommand,
+  readImportFile,
+  droppedSettings,
+  newCommands,
+  visible,
+  MAX_IMPORT_BYTES,
+  BACKUP_SUFFIX,
+};

package/src/cli/init.js

@@ -1,6 +1,24 @@
+"use strict";
+
 const fs = require("fs");
 const path = require("path");
-const { defaultConfig, saveConfig, setConfigDir } = require("../lib/shared");
+const {
+  defaultConfig,
+  saveConfig,
+  setConfigDir,
+  readConfigFile,
+  applyPreset,
+  renderStatusline,
+  sampleData,
+  resolveColorDepth,
+  PRESETS,
+  PRESET_ORDER,
+  LAYOUTS,
+  LAYOUT_ORDER,
+  THEMES,
+  THEME_ORDER,
+  canonicalThemeId,
+} = require("../lib/shared");
 const {
   AGY_SETTINGS,
   RUNTIME_FILES,
@@ -17,8 +35,10 @@ const {
   cmdBreakingChars,
   cmdBreakingMessage,
 } = require("../lib/paths");
-const { createRl, confirm } = require("../lib/prompt");
+const { createRl, confirm, choose } = require("../lib/prompt");
+const { printInvalidConfig } = require("./config-guard");
 const { buildRuntimeBundle } = require("./bundle");
+const { REPO_URL } = require("./repo-url");
 
 const DIM = "\x1b[2m";
 const BOLD = "\x1b[1m";
@@ -58,6 +78,117 @@ function assertUnixNode() {
   process.exit(1);
 }
 
+function unknownChoice(kind, value, ids) {
+  console.error(`${RED}error${RESET} Unknown ${kind} "${value}".`);
+  console.error(` Available ${kind}s: ${ids.join(", ")}`);
+  console.error(` Run ${CYAN}npx agy-powerline ${kind} --list${RESET} to view details.`);
+  process.exitCode = 1;
+  return null;
+}
+
+// --preset, --layout and --theme, checked before anything is written. Returns
+// the ids given ({} for none), or null after printing what's wrong.
+function readChoiceFlags(options) {
+  const choices = {};
+  if (options.preset !== undefined) {
+    if (!PRESETS[options.preset]) {
+      return unknownChoice("preset", options.preset, PRESET_ORDER);
+    }
+    choices.preset = options.preset;
+  }
+  if (options.layout !== undefined) {
+    if (!LAYOUTS[options.layout]) {
+      return unknownChoice("layout", options.layout, LAYOUT_ORDER);
+    }
+    choices.layout = options.layout;
+  }
+  if (options.theme !== undefined) {
+    // Aliases (dark, light, colorblind) name a theme too.
+    const theme = canonicalThemeId(options.theme);
+    if (!THEMES[theme]) {
+      return unknownChoice("theme", options.theme, THEME_ORDER);
+    }
+    choices.theme = theme;
+  }
+  return choices;
+}
+
+function applyChoices(config, choices) {
+  const next = choices.preset ? applyPreset(config, choices.preset) : { ...config };
+  if (choices.layout) {
+    next.layout = choices.layout;
+  }
+  if (choices.theme) {
+    next.theme = choices.theme;
+  }
+  return next;
+}
+
+// The bar a choice gives, fitted to the terminal's width (less the indent).
+// exec widgets keep their [cmd] placeholder: nothing runs here.
+function preview(config, rows = Infinity) {
+  const width = Math.max(40, (process.stdout.columns || 80) - 6);
+  const color = resolveColorDepth({ configColor: config.color, env: process.env });
+  return renderStatusline({ ...sampleData(), terminal_width: width }, config, { color })
+    .split("\n")
+    .slice(0, rows)
+    .join("\n");
+}
+
+const BACKGROUNDS = [
+  ["dark", "dark"],
+  ["light", "light"],
+  ["colorblind", "color-blind"],
+];
+
+// The questions of a first install in a terminal, for what the flags left open.
+async function askChoices(rl, given) {
+  const choices = { ...given };
+  const base = defaultConfig();
+  const option = (id, description, config, rows) =>
+    `${id}${description ? `  ${DIM}${description}${RESET}` : ""}\n${preview(config, rows)}`;
+
+  if (!choices.preset) {
+    const index = await choose(
+      rl,
+      `\n${BOLD} Which widgets?${RESET}`,
+      PRESET_ORDER.map((id) =>
+        option(id, PRESETS[id].description, applyChoices(base, { ...choices, preset: id }))
+      )
+    );
+    choices.preset = PRESET_ORDER[index];
+  }
+
+  if (!choices.layout) {
+    const index = await choose(
+      rl,
+      `\n${BOLD} Which layout?${RESET}`,
+      LAYOUT_ORDER.map((id) =>
+        option(id, LAYOUTS[id].description, applyChoices(base, { ...choices, layout: id }))
+      )
+    );
+    choices.layout = LAYOUT_ORDER[index];
+  }
+
+  if (!choices.theme) {
+    const background = await choose(
+      rl,
+      `\n${BOLD} Your terminal's background?${RESET}`,
+      BACKGROUNDS.map(([, label]) => label)
+    );
+    const kind = BACKGROUNDS[background][0];
+    const ids = THEME_ORDER.filter((id) => THEMES[id]?.kind === kind);
+    const index = await choose(
+      rl,
+      `\n${BOLD} Which theme?${RESET}`,
+      ids.map((id) => option(id, "", applyChoices(base, { ...choices, theme: id }), 1))
+    );
+    choices.theme = ids[index];
+  }
+
+  return choices;
+}
+
 function reportUnreadableSettings(error, command) {
   console.error(`${RED}error${RESET} ${AGY_SETTINGS} is not valid JSON, so it was left untouched.`);
   console.error(`  ${error}`);
@@ -74,12 +205,33 @@ async function initCommand(options = {}) {
   const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
   const installDir = resolveInstallDir();
   const command = statuslineCommand(installDir);
+  const destConfig = path.join(installDir, "statusline.config.json");
 
   console.log();
   console.log(`${CYAN}${BOLD} agy-powerline${RESET}`);
   console.log(`${DIM} Antigravity statusline installer${RESET}`);
   console.log();
 
+  let choices = readChoiceFlags(options);
+  if (!choices) {
+    return;
+  }
+
+  // Re-running init never replaces a config; flags change only their settings
+  // in it, and a config with a JSON error isn't touched at all.
+  const firstInstall = !fs.existsSync(destConfig);
+  let existingConfig = null;
+  if (!firstInstall && Object.keys(choices).length) {
+    setConfigDir(installDir);
+    const existing = readConfigFile();
+    if (existing.error) {
+      printInvalidConfig(existing.error);
+      process.exitCode = 1;
+      return;
+    }
+    existingConfig = existing.config;
+  }
+
   // Validate settings.json before writing anything, so a file we cannot
   // safely update never ends up half-installed or overwritten.
   const current = readSettingsForUpdate();
@@ -101,11 +253,18 @@ async function initCommand(options = {}) {
   const rl = interactive && !yes ? createRl() : null;
 
   try {
+    if (firstInstall && rl) {
+      choices = await askChoices(rl, choices);
+      console.log();
+      console.log(` ${BOLD}${choices.preset} · ${choices.layout} · ${choices.theme}${RESET}`);
+      console.log(preview(applyChoices(defaultConfig(), choices)));
+      console.log();
+    }
+
     fs.mkdirSync(installDir, { recursive: true });
     restrictPrivateFiles(installDir);
 
     const destStatusline = path.join(installDir, "statusline.js");
-    const destConfig = path.join(installDir, "statusline.config.json");
 
     let writeScripts = true;
 
@@ -144,9 +303,11 @@ async function initCommand(options = {}) {
 
     writeInstallMeta(installDir);
 
-    if (!fs.existsSync(destConfig)) {
-      setConfigDir(installDir);
-      saveConfig(defaultConfig());
+    setConfigDir(installDir);
+    if (firstInstall) {
+      saveConfig(applyChoices(defaultConfig(), choices));
+    } else if (existingConfig) {
+      saveConfig(applyChoices(existingConfig, choices));
     }
 
     const statusLine = await updateAgySettings(command, current, {
@@ -166,12 +327,24 @@ async function initCommand(options = {}) {
     if (typeof statusLine?.padding === "number") {
       console.log(`  padding  ${DIM}${statusLine.padding} line(s)${RESET}`);
     }
+    if (existingConfig) {
+      const changed = Object.entries(choices).map(([key, value]) => `${key} ${value}`);
+      console.log(`  config   ${DIM}kept yours, with ${changed.join(", ")}${RESET}`);
+    } else if (!firstInstall) {
+      console.log(`  config   ${DIM}kept yours${RESET}`);
+    }
     console.log();
     console.log(" Next:");
     console.log(`${CYAN}  npx agy-powerline configure${RESET}`);
+    console.log(
+      `${CYAN}  npx agy-powerline preset${RESET} / ${CYAN}layout${RESET} / ${CYAN}theme${RESET}  ${DIM}change one of your choices${RESET}`
+    );
     console.log(`${CYAN}  npx agy-powerline doctor${RESET}`);
     console.log("  then restart Antigravity / open a new session.");
     console.log();
+    console.log(`${DIM} Like it? A star on GitHub helps others find it:${RESET}`);
+    console.log(`${DIM}  ${REPO_URL}${RESET}`);
+    console.log();
   } finally {
     rl?.close();
   }
@@ -222,7 +395,7 @@ async function updateAgySettings(command, { exists, settings }, { yes, rl, stack
     statusLine.padding = settings.statusLine.padding;
   }
 
-  writeJsonSafely(AGY_SETTINGS, { ...settings, statusLine });
+  const originalBackup = writeJsonSafely(AGY_SETTINGS, { ...settings, statusLine });
 
   console.log(`${DIM}  ${exists ? "updated" : "created"} ${AGY_SETTINGS}${RESET}`);
   // init means "show the bar", so a statusLine switched off with enabled: false
@@ -233,10 +406,16 @@ async function updateAgySettings(command, { exists, settings }, { yes, rl, stack
   if (exists) {
     console.log(`${DIM}  backup  ${settingsBackupPath(AGY_SETTINGS)}${RESET}`);
   }
+  if (originalBackup) {
+    console.log(
+      `${DIM}  original  ${originalBackup} (kept as it was before agy-powerline)${RESET}`
+    );
+  }
 
   return statusLine;
 }
 
 module.exports = {
   initCommand,
+  askChoices,
 };

package/src/cli/layout.js

@@ -1,3 +1,5 @@
+"use strict";
+
 const {
   LAYOUTS,
   LAYOUT_ORDER,

package/src/cli/preset.js

@@ -1,3 +1,5 @@
+"use strict";
+
 const {
   PRESETS,
   PRESET_ORDER,

package/src/cli/repo-url.js

@@ -0,0 +1,7 @@
+"use strict";
+
+const { repository } = require("../../package.json");
+
+const REPO_URL = repository.url.replace(/^git\+/, "").replace(/\.git$/, "");
+
+module.exports = { REPO_URL };

package/src/cli/theme.js

@@ -1,3 +1,5 @@
+"use strict";
+
 const {
   THEMES,
   THEME_ORDER,

package/src/cli/uninstall.js

@@ -1,3 +1,5 @@
+"use strict";
+
 const fs = require("fs");
 const path = require("path");
 const {
@@ -66,8 +68,10 @@ function removeStatusLine(settings) {
   delete next.statusLine;
 
   if (Object.keys(next).length === 0) {
-    removeSettingsFile(AGY_SETTINGS);
-    return "settings file was empty, deleted";
+    // A symlinked settings.json is emptied rather than deleted (see paths.js).
+    return removeSettingsFile(AGY_SETTINGS) === "emptied"
+      ? "settings file was empty, emptied (it is a symlink)"
+      : "settings file was empty, deleted";
   }
 
   writeJsonSafely(AGY_SETTINGS, next);

package/src/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+"use strict";
 
 const fs = require("fs");
 const path = require("path");
@@ -9,6 +10,9 @@ const { themeCommand } = require("./cli/theme");
 const { layoutCommand } = require("./cli/layout");
 const { presetCommand } = require("./cli/preset");
 const { capsCommand } = require("./cli/caps");
+const { gradientCommand } = require("./cli/gradient");
+const { exportCommand } = require("./cli/export");
+const { importCommand } = require("./cli/import");
 const { doctorCommand } = require("./cli/doctor");
 const { uninstallCommand } = require("./cli/uninstall");
 const { reportCommand } = require("./cli/report");
@@ -46,6 +50,17 @@ const COMMANDS = [
         value: "<lines>",
         help: "set padding blank lines above statusline",
       },
+      preset: {
+        type: "string",
+        value: "<id>",
+        help: "start from this widget preset (skips the question)",
+      },
+      layout: { type: "string", value: "<id>", help: "use this layout (skips the question)" },
+      theme: {
+        type: "string",
+        value: "<id>",
+        help: "use this theme, or dark, light, colorblind (skips the question)",
+      },
     },
     run: (_arg, opts) =>
       initCommand({
@@ -103,6 +118,42 @@ const COMMANDS = [
     },
     run: (arg, opts) => capsCommand(arg, opts),
   },
+  {
+    name: "gradient",
+    arg: "[name]",
+    description:
+      "View or set a gradient across each row (a preset, hex colors like #ff5f6d-#ffc371, or off)",
+    options: {
+      list: { type: "boolean", short: "l", help: "list all gradient presets with a preview" },
+    },
+    run: (arg, opts) => gradientCommand(arg, opts),
+  },
+  {
+    name: "export",
+    arg: "[file]",
+    description: "Write your config to a file (or to stdout without one) to back it up or share it",
+    options: {
+      force: { type: "boolean", help: "replace the file if it already exists" },
+    },
+    run: (arg, opts) => exportCommand(arg, opts),
+  },
+  {
+    name: "import",
+    arg: "<file>",
+    description: "Load a config from a file, after showing what changes",
+    options: {
+      merge: {
+        type: "boolean",
+        help: "change only the settings the file has (default: replace the whole config)",
+      },
+      yes: { type: "boolean", short: "y", help: "apply without asking" },
+      "allow-exec": {
+        type: "boolean",
+        help: "accept the shell commands (exec widgets) the file adds; --yes alone doesn't",
+      },
+    },
+    run: (arg, opts) => importCommand(arg, opts),
+  },
   {
     name: "doctor",
     description: