@ipv9/tokentracker-cli 0.39.0

package/src/lib/claude-config.js

@@ -0,0 +1,204 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+
+const { ensureDir, readJson, writeJson } = require("./fs");
+
+const DEFAULT_EVENT = "SessionEnd";
+
+async function upsertClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  const existing = await readJson(settingsPath);
+  const settings = normalizeSettings(existing);
+  const hooks = normalizeHooks(settings.hooks);
+  const entries = normalizeEntries(hooks[event]);
+
+  const normalized = normalizeEntriesForCommand(entries, hookCommand);
+  if (normalized.changed) {
+    const nextHooks = { ...hooks, [event]: normalized.entries };
+    const nextSettings = { ...settings, hooks: nextHooks };
+    const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
+    return { changed: true, backupPath };
+  }
+
+  if (hasHook(entries, hookCommand)) {
+    return { changed: false, backupPath: null };
+  }
+
+  const nextEntries = entries.concat([{ hooks: [{ type: "command", command: hookCommand }] }]);
+  const nextHooks = { ...hooks, [event]: nextEntries };
+  const nextSettings = { ...settings, hooks: nextHooks };
+
+  const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
+  return { changed: true, backupPath };
+}
+
+async function removeClaudeHook({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  const existing = await readJson(settingsPath);
+  if (!existing) return { removed: false, skippedReason: "settings-missing" };
+
+  const settings = normalizeSettings(existing);
+  const hooks = normalizeHooks(settings.hooks);
+  const entries = normalizeEntries(hooks[event]);
+  if (entries.length === 0) return { removed: false, skippedReason: "hook-missing" };
+
+  let removed = false;
+  const nextEntries = [];
+  for (const entry of entries) {
+    const res = stripHookFromEntry(entry, hookCommand);
+    if (res.removed) removed = true;
+    if (res.entry) nextEntries.push(res.entry);
+  }
+
+  if (!removed) return { removed: false, skippedReason: "hook-missing" };
+
+  const nextHooks = { ...hooks };
+  if (nextEntries.length > 0) nextHooks[event] = nextEntries;
+  else delete nextHooks[event];
+
+  const nextSettings = { ...settings };
+  if (Object.keys(nextHooks).length > 0) nextSettings.hooks = nextHooks;
+  else delete nextSettings.hooks;
+
+  const backupPath = await writeClaudeSettings({ settingsPath, settings: nextSettings });
+  return { removed: true, skippedReason: null, backupPath };
+}
+
+async function isClaudeHookConfigured({ settingsPath, hookCommand, event = DEFAULT_EVENT }) {
+  const settings = await readJson(settingsPath);
+  if (!settings || typeof settings !== "object") return false;
+  const hooks = settings.hooks;
+  if (!hooks || typeof hooks !== "object") return false;
+  const entries = normalizeEntries(hooks[event]);
+  return hasHook(entries, hookCommand);
+}
+
+// Generic Session-hook command builder. CodeBuddy CLI is a Claude-Code fork
+// and uses the exact same settings.json hook schema, so this function works
+// for any source that accepts the `node notify.cjs --source=<name>` contract.
+function buildHookCommand(notifyPath, source) {
+  const cmd = typeof notifyPath === "string" ? notifyPath : "";
+  const src = typeof source === "string" && source ? source : "claude";
+  return `/usr/bin/env node ${quoteArg(cmd)} --source=${src}`;
+}
+
+function buildClaudeHookCommand(notifyPath) {
+  return buildHookCommand(notifyPath, "claude");
+}
+
+function normalizeSettings(raw) {
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+}
+
+function normalizeHooks(raw) {
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+}
+
+function normalizeEntries(raw) {
+  return Array.isArray(raw) ? raw.slice() : [];
+}
+
+function normalizeCommand(cmd) {
+  if (Array.isArray(cmd)) return cmd.map((v) => String(v)).join("\u0000");
+  if (typeof cmd === "string") return cmd.trim();
+  return null;
+}
+
+function hasHook(entries, hookCommand) {
+  for (const entry of entries) {
+    if (!entry || typeof entry !== "object") continue;
+    if (entry.command && commandsEqual(entry.command, hookCommand)) return true;
+    const hooks = Array.isArray(entry.hooks) ? entry.hooks : [];
+    for (const hook of hooks) {
+      if (hook && commandsEqual(hook.command, hookCommand)) return true;
+    }
+  }
+  return false;
+}
+
+function stripHookFromEntry(entry, hookCommand) {
+  if (!entry || typeof entry !== "object") return { entry, removed: false };
+
+  if (entry.command) {
+    if (commandsEqual(entry.command, hookCommand)) return { entry: null, removed: true };
+    return { entry, removed: false };
+  }
+
+  const hooks = Array.isArray(entry.hooks) ? entry.hooks : null;
+  if (!hooks) return { entry, removed: false };
+
+  const nextHooks = hooks.filter((hook) => !commandsEqual(hook?.command, hookCommand));
+  if (nextHooks.length === hooks.length) return { entry, removed: false };
+  if (nextHooks.length === 0) return { entry: null, removed: true };
+
+  return { entry: { ...entry, hooks: nextHooks }, removed: true };
+}
+
+function normalizeEntriesForCommand(entries, hookCommand) {
+  let changed = false;
+  const nextEntries = entries.map((entry) => {
+    if (!entry || typeof entry !== "object") return entry;
+    if (entry.command && commandsEqual(entry.command, hookCommand)) {
+      if (entry.type !== "command") {
+        changed = true;
+        return { ...entry, type: "command" };
+      }
+      return entry;
+    }
+    if (!Array.isArray(entry.hooks)) return entry;
+    let hooksChanged = false;
+    const nextHooks = entry.hooks.map((hook) => {
+      if (hook && commandsEqual(hook.command, hookCommand)) {
+        if (hook.type !== "command") {
+          hooksChanged = true;
+          return { ...hook, type: "command" };
+        }
+      }
+      return hook;
+    });
+    if (!hooksChanged) return entry;
+    changed = true;
+    return { ...entry, hooks: nextHooks };
+  });
+  return { entries: nextEntries, changed };
+}
+
+function commandsEqual(a, b) {
+  const left = normalizeCommand(a);
+  const right = normalizeCommand(b);
+  return Boolean(left && right && left === right);
+}
+
+function quoteArg(value) {
+  const v = typeof value === "string" ? value : "";
+  if (!v) return '""';
+  if (/^[A-Za-z0-9_\-./:@]+$/.test(v)) return v;
+  return `"${v.replace(/"/g, '\\"')}"`;
+}
+
+async function writeClaudeSettings({ settingsPath, settings }) {
+  await ensureDir(path.dirname(settingsPath));
+  let backupPath = null;
+  try {
+    const st = await fs.stat(settingsPath);
+    if (st && st.isFile()) {
+      backupPath = `${settingsPath}.bak.${new Date().toISOString().replace(/[:.]/g, "-")}`;
+      await fs.copyFile(settingsPath, backupPath);
+    }
+  } catch (_e) {
+    // Ignore missing file.
+  }
+  await writeJson(settingsPath, settings);
+  return backupPath;
+}
+
+module.exports = {
+  upsertClaudeHook,
+  removeClaudeHook,
+  isClaudeHookConfigured,
+  buildClaudeHookCommand,
+  buildHookCommand,
+  // Aliases for callers that want a name unbiased toward Claude (the schema
+  // applies equally to CodeBuddy and any future Claude-Code fork).
+  upsertSessionHook: upsertClaudeHook,
+  removeSessionHook: removeClaudeHook,
+  isSessionHookConfigured: isClaudeHookConfigured,
+};

package/src/lib/cli-ui.js

@@ -0,0 +1,179 @@
+const readline = require("node:readline");
+
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const CYAN = "\x1b[36m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const BLUE = "\x1b[34m";
+const UNDERLINE = "\x1b[4m";
+
+const SPINNER_FRAMES = ["|", "/", "-", "\\"];
+
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+function formatLine(line, width) {
+  if (!width) return line;
+  const raw = String(line || "");
+  const pad = Math.max(0, width - raw.length);
+  return raw + " ".repeat(pad);
+}
+
+function renderBox(lines, { padding = 1 } = {}) {
+  const content = lines.map((line) => String(line || ""));
+  const maxLen = content.reduce((max, line) => Math.max(max, line.length), 0);
+  const innerWidth = maxLen + padding * 2;
+  const top = `+${"-".repeat(innerWidth)}+`;
+  const bottom = `+${"-".repeat(innerWidth)}+`;
+  const body = content.map((line) => {
+    const padded = " ".repeat(padding) + formatLine(line, maxLen) + " ".repeat(padding);
+    return `|${padded}|`;
+  });
+  return [top, ...body, bottom].join("\n");
+}
+
+function color(text, token) {
+  return `${token}${text}${RESET}`;
+}
+
+function underline(text) {
+  return `${UNDERLINE}${text}${RESET}`;
+}
+
+async function promptEnter(message) {
+  if (!isInteractive()) return;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  await new Promise((resolve) => rl.question(message, () => resolve()));
+  rl.close();
+}
+
+async function promptMenu({ message, options, defaultIndex = 0 }) {
+  if (!isInteractive()) return options[defaultIndex] || options[0];
+
+  const safeOptions = Array.isArray(options) ? options : [];
+  if (safeOptions.length === 0) return "";
+
+  const maxIndex = safeOptions.length - 1;
+  let currentIndex = Math.min(Math.max(defaultIndex, 0), maxIndex);
+  const promptMessage = `${message} (Use Up/Down arrows, Enter)`;
+  const linesCount = safeOptions.length + 1;
+
+  const renderLines = () => {
+    const lines = [promptMessage];
+    safeOptions.forEach((opt, idx) => {
+      const prefix = idx === currentIndex ? ">" : " ";
+      lines.push(`${prefix} ${opt}`);
+    });
+    process.stdout.write(lines.join("\n"));
+  };
+
+  const rerender = () => {
+    for (let i = 0; i < linesCount; i += 1) {
+      process.stdout.write("\x1b[2K");
+      if (i < linesCount - 1) process.stdout.write("\x1b[1A");
+    }
+    process.stdout.write("\r");
+    renderLines();
+  };
+
+  renderLines();
+
+  return await new Promise((resolve) => {
+    const cleanup = () => {
+      process.stdin.off("keypress", onKeypress);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write("\n");
+    };
+
+    const onKeypress = (str, key = {}) => {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        return resolve(safeOptions[currentIndex]);
+      }
+      if (key.name === "up" || str === "k") {
+        currentIndex = currentIndex === 0 ? maxIndex : currentIndex - 1;
+        rerender();
+        return;
+      }
+      if (key.name === "down" || str === "j") {
+        currentIndex = currentIndex === maxIndex ? 0 : currentIndex + 1;
+        rerender();
+        return;
+      }
+      if (key.name === "return") {
+        cleanup();
+        return resolve(safeOptions[currentIndex]);
+      }
+      if (str && /^[1-9]$/.test(str)) {
+        const idx = Number.parseInt(str, 10) - 1;
+        if (idx >= 0 && idx <= maxIndex) {
+          currentIndex = idx;
+          cleanup();
+          return resolve(safeOptions[currentIndex]);
+        }
+      }
+    };
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("keypress", onKeypress);
+  });
+}
+
+function createSpinner({ text, intervalMs = 80 }) {
+  let frame = 0;
+  let timer = null;
+
+  function start() {
+    if (!isInteractive()) {
+      process.stdout.write(`${text}\n`);
+      return;
+    }
+    timer = setInterval(() => {
+      const glyph = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+      frame += 1;
+      process.stdout.write(`\r${glyph} ${text}`);
+    }, intervalMs);
+  }
+
+  function stop(successText) {
+    if (timer) clearInterval(timer);
+    if (isInteractive()) {
+      process.stdout.write(`\r${" ".repeat(text.length + 4)}\r`);
+    }
+    if (successText) process.stdout.write(`${successText}\n`);
+  }
+
+  return { start, stop };
+}
+
+function formatSummaryLine({ label, status, detail }) {
+  const isSuccess = status === "updated" || status === "set" || status === "installed";
+  const bullet = isSuccess ? color("*", GREEN) : "o";
+  const statusLabel = isSuccess ? detail || status : detail ? `Skipped - ${detail}` : "Skipped";
+  const line = `  ${bullet} ${label.padEnd(22)} [${statusLabel}]`;
+  return isSuccess ? line : color(line, DIM);
+}
+
+module.exports = {
+  BOLD,
+  DIM,
+  CYAN,
+  GREEN,
+  YELLOW,
+  BLUE,
+  RESET,
+  color,
+  underline,
+  renderBox,
+  isInteractive,
+  promptMenu,
+  promptEnter,
+  createSpinner,
+  formatSummaryLine,
+};