lithermes-ai 0.5.0

package/src/lib/patch.js

@@ -0,0 +1,153 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { sha256, writeFileAtomic } = require("./files");
+const { LitHermesError } = require("./hermesDiscovery");
+
+function patchManifestPath(hermesHome) {
+  return path.join(hermesHome, "lithermes", "patch-manifest.json");
+}
+
+function patchTarget(repo, relative, marker, additions) {
+  const file = path.join(repo, relative);
+  if (!fs.existsSync(file)) {
+    return null;
+  }
+  const source = fs.readFileSync(file, "utf8");
+  if (additions.every((text) => source.includes(text))) {
+    return null;
+  }
+  if (!source.includes(marker)) {
+    throw new LitHermesError(`Unsupported Hermes preimage for ${relative}; refusing to patch without a known marker.`, 8);
+  }
+  const backup = `${file}.lithermes.bak`;
+  fs.copyFileSync(file, backup);
+  const beforeHash = sha256(file);
+  const backupHash = sha256(backup);
+  const patched = `${source.replace(/\s*$/, "\n")}\n# LitHermes compatibility patch\n${additions.map((text) => `# ${text}`).join("\n")}\n`;
+  writeFileAtomic(file, patched, "utf8");
+  return {
+    file,
+    relative,
+    backup,
+    beforeHash,
+    backupHash,
+    patchedHash: sha256(file),
+  };
+}
+
+function patchCliPayloadDispatch(repo) {
+  const relative = "cli.py";
+  const file = path.join(repo, relative);
+  if (!fs.existsSync(file)) return null;
+  const source = fs.readFileSync(file, "utf8");
+  if (source.includes("_pending_input.put") && source.includes("agent_message") && source.includes("ast.literal_eval")) {
+    return null;
+  }
+
+  const marker = [
+    "                        result = resolve_plugin_command_result(",
+    "                            plugin_handler(user_args)",
+    "                        )",
+    "                        if result:",
+    "                            _cprint(str(result))",
+  ].join("\n");
+  if (!source.includes(marker)) {
+    throw new LitHermesError(`Unsupported Hermes preimage for ${relative}; plugin command dispatch block not recognized.`, 8);
+  }
+
+  const replacement = [
+    "                        result = resolve_plugin_command_result(",
+    "                            plugin_handler(user_args)",
+    "                        )",
+    "                        if isinstance(result, str) and \"agent_message\" in result:",
+    "                            try:",
+    "                                parsed = ast.literal_eval(result)",
+    "                            except (SyntaxError, ValueError):",
+    "                                parsed = None",
+    "                            if isinstance(parsed, dict):",
+    "                                result = parsed",
+    "                        if isinstance(result, dict) and result.get(\"agent_message\"):",
+    "                            display = result.get(\"display\") or result.get(\"message\")",
+    "                            if display:",
+    "                                _cprint(str(display))",
+    "                            if hasattr(self, '_pending_input'):",
+    "                                self._pending_input.put(str(result[\"agent_message\"]))",
+    "                        elif result:",
+    "                            _cprint(str(result))",
+  ].join("\n");
+
+  const backup = `${file}.lithermes.bak`;
+  fs.copyFileSync(file, backup);
+  const beforeHash = sha256(file);
+  const backupHash = sha256(backup);
+  writeFileAtomic(file, source.replace(marker, replacement), "utf8");
+  return {
+    file,
+    relative,
+    backup,
+    beforeHash,
+    backupHash,
+    patchedHash: sha256(file),
+  };
+}
+
+function patchInstalledHermes({ hermesHome, hermesRepo }) {
+  if (!hermesRepo || !fs.existsSync(hermesRepo)) {
+    throw new LitHermesError("Cannot patch Hermes because --hermes-repo was not found. Pass --hermes-repo PATH or run doctor first.", 8);
+  }
+  const changed = [];
+  const records = [];
+  const cli = patchCliPayloadDispatch(hermesRepo);
+  if (cli) {
+    changed.push("cli.py");
+    records.push(cli);
+  }
+  const gateway = patchTarget(hermesRepo, path.join("gateway", "run.py"), "lithermes-patch-target:gateway", [
+    'command.replace("_", "-")',
+    "_plugin_agent_dispatch_payload",
+  ]);
+  if (gateway) {
+    changed.push("gateway/run.py");
+    records.push(gateway);
+  }
+  const plugins = patchTarget(hermesRepo, path.join("hermes_cli", "plugins.py"), "lithermes-patch-target:plugins", [
+    "auto_load",
+    "plugins.enabled",
+  ]);
+  if (plugins) {
+    changed.push("hermes_cli/plugins.py");
+    records.push(plugins);
+  }
+  fs.mkdirSync(path.dirname(patchManifestPath(hermesHome)), { recursive: true });
+  writeFileAtomic(patchManifestPath(hermesHome), JSON.stringify({ patchedAt: new Date().toISOString(), records }, null, 2), "utf8");
+  return { changed, records };
+}
+
+function rollbackPatches({ hermesHome }) {
+  const manifest = patchManifestPath(hermesHome);
+  if (!fs.existsSync(manifest)) {
+    return { message: "No LitHermes patches to roll back." };
+  }
+  const parsed = JSON.parse(fs.readFileSync(manifest, "utf8"));
+  const restored = [];
+  for (const record of [...parsed.records].reverse()) {
+    if (!fs.existsSync(record.file) || !fs.existsSync(record.backup)) {
+      throw new LitHermesError(`Cannot roll back ${record.relative}; patched file or backup is missing.`, 9);
+    }
+    if (sha256(record.file) !== record.patchedHash || sha256(record.backup) !== record.backupHash) {
+      throw new LitHermesError(`Cannot roll back ${record.relative}; file hash changed after patch.`, 9);
+    }
+    fs.copyFileSync(record.backup, record.file);
+    fs.unlinkSync(record.backup);
+    restored.push(record.relative);
+  }
+  fs.unlinkSync(manifest);
+  return { message: `Rolled back LitHermes patches: ${restored.join(", ") || "none"}` };
+}
+
+module.exports = {
+  patchCliPayloadDispatch,
+  patchInstalledHermes,
+  patchManifestPath,
+  rollbackPatches,
+};

package/src/lib/skins.js

@@ -0,0 +1,113 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { writeFileAtomic } = require("./files");
+
+// LitHermes HUD accents — 10 presets that drive Hermes' native skin engine.
+// Each becomes ~/.hermes/skins/lithermes-<accent>.yaml; activated via
+// `display.skin` in config.yaml or `/skin lithermes-<accent>` inside Hermes.
+//
+// A curated 10-accent palette (name + ANSI-256 code + order); `hex` is a
+// neon-vivid color of the same hue (Hermes skins use hex, not ANSI codes).
+// ⚠️  accent, code, and order are frozen by tests — do NOT reorder.
+const HUD_ACCENTS = [
+  { accent: "cyan",     code: 81,  hex: "#00F5FF", label: "Cyan",     mood: "neon ice" },
+  { accent: "blue",     code: 39,  hex: "#00B4FF", label: "Blue",     mood: "arc flash" },
+  { accent: "teal",     code: 49,  hex: "#00FFB2", label: "Teal",     mood: "plasma teal" },
+  { accent: "green",    code: 118, hex: "#39FF14", label: "Green",    mood: "laser green" },
+  { accent: "lavender", code: 177, hex: "#E040FB", label: "Lavender", mood: "neon violet" },
+  { accent: "rose",     code: 198, hex: "#FF0066", label: "Rose",     mood: "hot magenta" },
+  { accent: "gold",     code: 220, hex: "#FFE600", label: "Gold",     mood: "volt gold" },
+  { accent: "orange",   code: 208, hex: "#FF6200", label: "Orange",   mood: "ember glow" },
+  { accent: "slate",    code: 75,  hex: "#33AAFF", label: "Slate",    mood: "cold steel" },
+  { accent: "gray",     code: 231, hex: "#F0F0F0", label: "Gray",     mood: "soft white" },
+];
+
+function skinName(accent) {
+  return `lithermes-${accent}`;
+}
+
+function skinsDir(hermesHome) {
+  return path.join(hermesHome, "skins");
+}
+
+// Hermes skins inherit every unset field from the `default` skin, so an accent
+// preset only needs to retint the primary accent color keys.
+function renderSkinYaml(entry) {
+  const h = entry.hex;
+  return [
+    `name: ${skinName(entry.accent)}`,
+    `description: LitHermes ${entry.label} accent HUD`,
+    "colors:",
+    `  banner_title: "${h}"`,
+    `  banner_accent: "${h}"`,
+    `  banner_border: "${h}"`,
+    `  ui_accent: "${h}"`,
+    `  ui_label: "${h}"`,
+    `  input_rule: "${h}"`,
+    `  response_border: "${h}"`,
+    `  status_bar_strong: "${h}"`,
+    `  session_label: "${h}"`,
+    "",
+  ].join("\n");
+}
+
+function findAccent(token) {
+  const raw = String(token == null ? "" : token).trim().toLowerCase();
+  if (!raw) return null;
+  const bare = raw.startsWith("lithermes-") ? raw.slice("lithermes-".length) : raw;
+  const byName = HUD_ACCENTS.find((a) => a.accent === bare);
+  if (byName) return byName;
+  if (/^\d+$/.test(raw)) {
+    const idx = Number(raw) - 1;
+    if (idx >= 0 && idx < HUD_ACCENTS.length) return HUD_ACCENTS[idx];
+  }
+  return null;
+}
+
+function installSkins(hermesHome) {
+  const dir = skinsDir(hermesHome);
+  fs.mkdirSync(dir, { recursive: true });
+  const written = [];
+  for (const entry of HUD_ACCENTS) {
+    const file = path.join(dir, `${skinName(entry.accent)}.yaml`);
+    writeFileAtomic(file, renderSkinYaml(entry), "utf8");
+    written.push(file);
+  }
+  return written;
+}
+
+function hexToRgb(hex) {
+  const m = /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(String(hex));
+  if (!m) return null;
+  return [parseInt(m[1], 16), parseInt(m[2], 16), parseInt(m[3], 16)];
+}
+
+function supportsColor({ stream = process.stdout, env = process.env } = {}) {
+  if (env.NO_COLOR) return false;
+  if (env.TERM === "dumb") return false;
+  return Boolean(stream && stream.isTTY);
+}
+
+// Accent swatch (●●) used to preview an accent in the picker list. Prefers the
+// exact ANSI-256 `code` in bold+bright for a neon-glow feel; falls back to
+// 24-bit truecolor from hex. No-color path returns a plain asterisk.
+function swatch(hex, { color = true, code = null } = {}) {
+  if (!color) return "*";
+  // Bold (\x1b[1m) + ANSI-256 fg + double dot for width/glow feel + reset
+  if (code != null) return `\x1b[1m\x1b[38;5;${code}m●●\x1b[0m`;
+  const rgb = hexToRgb(hex);
+  if (!rgb) return "*";
+  return `\x1b[1m\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m●●\x1b[0m`;
+}
+
+module.exports = {
+  HUD_ACCENTS,
+  skinName,
+  skinsDir,
+  renderSkinYaml,
+  findAccent,
+  installSkins,
+  hexToRgb,
+  supportsColor,
+  swatch,
+};

package/src/lib/spinner.js

@@ -0,0 +1,104 @@
+const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+function shouldUseSpinner({ stream = process.stderr, env = process.env, flags = {} } = {}) {
+  if (flags["dry-run"] || flags["no-spinner"]) return false;
+  if (flags.spinner) return true;
+  if (env.LITHERMES_FORCE_SPINNER === "1") return true;
+  if (env.CI || env.NO_COLOR || env.TERM === "dumb") return false;
+  return Boolean(stream && stream.isTTY);
+}
+
+function useColor({ env = process.env } = {}) {
+  if (env.NO_COLOR) return false;
+  if (env.TERM === "dumb") return false;
+  return true;
+}
+
+// Minimal ANSI palette. Colours are stripped when NO_COLOR/TERM=dumb is set.
+function makePalette(enabled) {
+  const wrap = (open, close) => (s) => (enabled ? `\x1b[${open}m${s}\x1b[${close}m` : s);
+  return {
+    bold: wrap(1, 22),
+    dim: wrap(2, 22),
+    green: wrap(32, 39),
+    red: wrap(31, 39),
+    cyan: wrap(36, 39),
+  };
+}
+
+// Step-aware install renderer. Each onProgress phase becomes a live spinner line
+// that is finalized in place with its own ✓ (or ✗ on failure), producing an
+// ordered checklist. Preserves the legacy single-spinner tokens that existing
+// tests pin: hidden/shown cursor, braille frames, header text, and completion text.
+function createSpinner({ stream = process.stderr, text = "Installing LitHermes", env = process.env } = {}) {
+  const c = makePalette(useColor({ env }));
+  let frameIndex = 0;
+  let timer = null;
+  let active = false;
+  let currentLabel = null;
+  let stepStart = 0;
+
+  function elapsed() {
+    if (!stepStart) return "";
+    const secs = (Date.now() - stepStart) / 1000;
+    return c.dim(` (${secs.toFixed(1)}s)`);
+  }
+
+  function paintActive() {
+    const frame = c.cyan(frames[frameIndex % frames.length]);
+    frameIndex += 1;
+    stream.write(`\r${frame} ${currentLabel}${elapsed()}\x1b[K`);
+  }
+
+  function clearTimer() {
+    if (timer) clearInterval(timer);
+    timer = null;
+  }
+
+  // Finalize the active step line in place with a status glyph, then newline so
+  // it persists above the next step.
+  function finalizeCurrent(glyph) {
+    if (currentLabel === null) return;
+    clearTimer();
+    stream.write(`\r${glyph} ${currentLabel}${elapsed()}\x1b[K\n`);
+    currentLabel = null;
+  }
+
+  function startStep(label) {
+    currentLabel = label;
+    stepStart = Date.now();
+    paintActive();
+    timer = setInterval(paintActive, 80);
+    if (timer && typeof timer.unref === "function") timer.unref();
+  }
+
+  return {
+    start() {
+      if (active) return;
+      active = true;
+      stream.write("\x1b[?25l");
+      stream.write(`${c.bold(text)}\n`);
+    },
+    update(nextText) {
+      if (!active) return;
+      finalizeCurrent(c.green("✓"));
+      startStep(nextText);
+    },
+    succeed(message = "LitHermes install ready") {
+      if (!active) return;
+      finalizeCurrent(c.green("✓"));
+      clearTimer();
+      active = false;
+      stream.write(`${c.green("✓")} ${message}\n\x1b[?25h`);
+    },
+    fail(message = "LitHermes install failed") {
+      if (!active) return;
+      finalizeCurrent(c.red("✕"));
+      clearTimer();
+      active = false;
+      stream.write(`${c.red("✕")} ${message}\n\x1b[?25h`);
+    },
+  };
+}
+
+module.exports = { createSpinner, shouldUseSpinner };