@delt/claude-jev-advisor 0.1.0

package/dist/cli.js

@@ -0,0 +1,642 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import os from "os";
+import path8 from "path";
+import { fileURLToPath } from "url";
+
+// src/cli/run.ts
+import path7 from "path";
+
+// src/features.ts
+var FEATURES = ["rm", "context"];
+var HOOK_SPECS = {
+  rm: [{ event: "PreToolUse", matcher: "Bash", script: "rm-hook.js", args: [] }],
+  context: [
+    { event: "Stop", script: "context-hook.js", args: ["stop"] },
+    { event: "SessionEnd", script: "context-hook.js", args: ["session-end"] }
+  ]
+};
+var SUPPORTED_PLATFORMS = {
+  rm: ["win32"],
+  context: null
+};
+var HOOK_TIMEOUT_SECONDS = 15;
+var LEGACY_RM_GUARD = /\/\.claude\/hooks\/rm-guard\/rm-guard\.mjs/;
+var STATUSLINE_SCRIPT = "statusline.js";
+var MOD_PLUGIN_NAME = "jev-advisor";
+var MOD_DIR_PATTERN = /claude-jev-advisor\/mod\/?$/;
+function ownScriptPattern(script) {
+  return new RegExp(`claude-jev-advisor/dist/${script.replace(/\./g, "\\.")}`);
+}
+function isFeature(value) {
+  return FEATURES.includes(value);
+}
+
+// src/install.ts
+import path5 from "path";
+
+// src/config.ts
+import fs from "fs";
+import path2 from "path";
+
+// src/config-shape.ts
+var DEFAULT_CONFIG = {
+  lang: "ko",
+  keyFile: null,
+  display: "mod",
+  context: { enabled: true, minTokens: 1e5, compactMinTokens: 2e5, redRemainingPct: 20, unitDoneYes: 0.7, goalDoneYes: 0.8 },
+  rm: { enabled: true, jev: true, throwawayYes: 0.8, maxDirFiles: 50 }
+};
+var LANGS = ["ko", "en"];
+var DISPLAYS = ["mod", "statusline", "message"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeSection(defaults, raw) {
+  const out = { ...defaults };
+  if (!isRecord(raw)) return out;
+  for (const [key, value] of Object.entries(defaults)) {
+    if (typeof raw[key] === typeof value) out[key] = raw[key];
+  }
+  return out;
+}
+function normalizeConfig(raw) {
+  const r = isRecord(raw) ? raw : {};
+  return {
+    lang: typeof r.lang === "string" && LANGS.includes(r.lang) ? r.lang : DEFAULT_CONFIG.lang,
+    keyFile: typeof r.keyFile === "string" && r.keyFile !== "" ? r.keyFile : null,
+    display: typeof r.display === "string" && DISPLAYS.includes(r.display) ? r.display : DEFAULT_CONFIG.display,
+    context: mergeSection(DEFAULT_CONFIG.context, r.context),
+    rm: mergeSection(DEFAULT_CONFIG.rm, r.rm)
+  };
+}
+
+// src/paths.ts
+import path from "path";
+var claudeDir = (home) => path.join(home, ".claude");
+var dataDir = (home) => path.join(claudeDir(home), "claude-jev-advisor");
+var configPath = (home) => path.join(dataDir(home), "config.json");
+var settingsPath = (home) => path.join(claudeDir(home), "settings.json");
+var backupsDir = (home) => path.join(claudeDir(home), "backups");
+var stateDir = (home) => path.join(dataDir(home), "state");
+var statusLineBeforePath = (home) => path.join(dataDir(home), "statusline-before.json");
+
+// src/config.ts
+function readConfig(home) {
+  try {
+    return normalizeConfig(JSON.parse(fs.readFileSync(configPath(home), "utf8").replace(/^\uFEFF/, "")));
+  } catch {
+    return normalizeConfig({});
+  }
+}
+function writeConfig(home, config) {
+  const file = configPath(home);
+  fs.mkdirSync(path2.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(config, null, 2)}
+`);
+}
+function updateConfig(home, change) {
+  const next = change(readConfig(home));
+  writeConfig(home, next);
+  return next;
+}
+
+// src/display/settings.ts
+import fs2 from "fs";
+import path3 from "path";
+
+// src/settings.ts
+var forwardSlashes = (text) => text.replace(/\\/g, "/");
+function hookCommand(scriptPath, ...args) {
+  return [`node "${forwardSlashes(scriptPath)}"`, ...args].join(" ");
+}
+function commandMatches(command, pattern) {
+  return pattern.test(forwardSlashes(command));
+}
+function withHook(settings, entry) {
+  const group = {
+    ...entry.matcher === void 0 ? {} : { matcher: entry.matcher },
+    hooks: [{ type: "command", command: entry.command, timeout: entry.timeout }]
+  };
+  const hooks = { ...settings.hooks ?? {} };
+  hooks[entry.event] = [...hooks[entry.event] ?? [], group];
+  return { ...settings, hooks };
+}
+function withoutCommands(settings, pattern) {
+  if (!settings.hooks) return settings;
+  const isOurs = (h) => typeof h.command === "string" && commandMatches(h.command, pattern);
+  const hooks = {};
+  let removedAny = false;
+  for (const [event, groups] of Object.entries(settings.hooks)) {
+    const kept = [];
+    let emptiedByUs = false;
+    for (const group of groups) {
+      if (!Array.isArray(group.hooks) || !group.hooks.some(isOurs)) {
+        kept.push(group);
+        continue;
+      }
+      removedAny = true;
+      const remaining = group.hooks.filter((h) => !isOurs(h));
+      if (remaining.length) kept.push({ ...group, hooks: remaining });
+      else emptiedByUs = true;
+    }
+    if (kept.length || !emptiedByUs) hooks[event] = kept;
+  }
+  if (!removedAny) return settings;
+  if (!Object.keys(hooks).length) {
+    const { hooks: _removed, ...rest } = settings;
+    return rest;
+  }
+  return { ...settings, hooks };
+}
+function findCommands(settings, pattern) {
+  const found = [];
+  for (const [event, groups] of Object.entries(settings.hooks ?? {})) {
+    for (const group of groups) {
+      if (!Array.isArray(group.hooks)) continue;
+      for (const hook of group.hooks) {
+        if (typeof hook.command === "string" && commandMatches(hook.command, pattern)) found.push({ event, matcher: group.matcher, command: hook.command });
+      }
+    }
+  }
+  return found;
+}
+
+// src/display/settings.ts
+var PLUGIN_DIRS_ENV = "CLAUDE_CODE_PLUGIN_DIRS";
+var STATUSLINE_REFRESH_SECONDS = 3;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var forwardSlashes2 = (text) => text.replace(/\\/g, "/");
+function withoutKey(settings, key) {
+  const { [key]: _removed, ...rest } = settings;
+  return rest;
+}
+function withoutModDisplay(settings, delimiter) {
+  let next = settings;
+  const env = isRecord2(settings.env) ? settings.env : null;
+  const dirs = env?.[PLUGIN_DIRS_ENV];
+  if (env && typeof dirs === "string") {
+    const all = dirs.split(delimiter);
+    const kept = all.filter((dir) => !MOD_DIR_PATTERN.test(forwardSlashes2(dir)));
+    if (kept.length !== all.length) {
+      const { [PLUGIN_DIRS_ENV]: _ours, ...otherEnv } = env;
+      const nextEnv = kept.length ? { ...env, [PLUGIN_DIRS_ENV]: kept.join(delimiter) } : otherEnv;
+      next = Object.keys(nextEnv).length ? { ...next, env: nextEnv } : withoutKey(next, "env");
+    }
+  }
+  const configs = isRecord2(next.pluginConfigs) ? next.pluginConfigs : null;
+  if (configs && MOD_PLUGIN_NAME in configs) {
+    const { [MOD_PLUGIN_NAME]: _ours, ...others } = configs;
+    next = Object.keys(others).length ? { ...next, pluginConfigs: others } : withoutKey(next, "pluginConfigs");
+  }
+  return next;
+}
+function withModDisplay(settings, modDir, dataDirPath, delimiter) {
+  const base = withoutModDisplay(settings, delimiter);
+  const env = isRecord2(base.env) ? base.env : {};
+  const dirs = typeof env[PLUGIN_DIRS_ENV] === "string" && env[PLUGIN_DIRS_ENV] !== "" ? `${env[PLUGIN_DIRS_ENV]}${delimiter}` : "";
+  const configs = isRecord2(base.pluginConfigs) ? base.pluginConfigs : {};
+  return {
+    ...base,
+    env: { ...env, [PLUGIN_DIRS_ENV]: `${dirs}${forwardSlashes2(modDir)}` },
+    pluginConfigs: { ...configs, [MOD_PLUGIN_NAME]: { options: { dataDir: forwardSlashes2(dataDirPath) } } }
+  };
+}
+function isOurStatusLine(value) {
+  return isRecord2(value) && typeof value.command === "string" && commandMatches(value.command, ownScriptPattern(STATUSLINE_SCRIPT));
+}
+function readStatusLineBefore(home) {
+  try {
+    const value = JSON.parse(fs2.readFileSync(statusLineBeforePath(home), "utf8"));
+    return isRecord2(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function writeStatusLineBefore(home, value) {
+  const file = statusLineBeforePath(home);
+  if (!value) {
+    fs2.rmSync(file, { force: true });
+    return;
+  }
+  fs2.mkdirSync(path3.dirname(file), { recursive: true });
+  fs2.writeFileSync(file, `${JSON.stringify(value, null, 2)}
+`);
+}
+function applyStatusLineDisplay(settings, home, command) {
+  const current = settings.statusLine;
+  const ours = isOurStatusLine(current);
+  const userLine = ours ? readStatusLineBefore(home) : isRecord2(current) ? current : null;
+  if (command !== null) {
+    writeStatusLineBefore(home, userLine);
+    return { ...settings, statusLine: { type: "command", command, refreshInterval: STATUSLINE_REFRESH_SECONDS } };
+  }
+  if (!ours) return settings;
+  return userLine ? { ...settings, statusLine: userLine } : withoutKey(settings, "statusLine");
+}
+function forgetStatusLineBefore(home, settings) {
+  if (!isOurStatusLine(settings.statusLine)) writeStatusLineBefore(home, null);
+}
+
+// src/settings-file.ts
+import fs3 from "fs";
+import path4 from "path";
+function readSettingsFile(file) {
+  let text;
+  try {
+    text = fs3.readFileSync(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+  const parsed = JSON.parse(text.replace(/^\uFEFF/, ""));
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error(`${file} does not hold a JSON object`);
+  return parsed;
+}
+function backupName(now) {
+  const two = (n) => String(n).padStart(2, "0");
+  const stamp = `${now.getFullYear()}-${two(now.getMonth() + 1)}-${two(now.getDate())}-${two(now.getHours())}${two(now.getMinutes())}${two(now.getSeconds())}`;
+  return `settings.json.${stamp}-before-claude-jev-advisor`;
+}
+function backupSettingsFile(file, dir, now) {
+  if (!fs3.existsSync(file)) return null;
+  fs3.mkdirSync(dir, { recursive: true });
+  const baseName = backupName(now);
+  let target = path4.join(dir, baseName);
+  let suffix = 2;
+  while (true) {
+    try {
+      fs3.copyFileSync(file, target, fs3.constants.COPYFILE_EXCL);
+      return target;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        target = path4.join(dir, `${baseName}-${suffix}`);
+        suffix++;
+      } else {
+        throw err;
+      }
+    }
+  }
+}
+function writeSettingsFile(file, settings) {
+  fs3.mkdirSync(path4.dirname(file), { recursive: true });
+  const temp = `${file}.claude-jev-advisor.tmp`;
+  fs3.writeFileSync(temp, `${JSON.stringify(settings, null, 2)}
+`);
+  try {
+    fs3.renameSync(temp, file);
+  } catch (err) {
+    try {
+      fs3.unlinkSync(temp);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+// src/install.ts
+function withoutFeature(settings, feature) {
+  return HOOK_SPECS[feature].reduce((s, spec) => withoutCommands(s, ownScriptPattern(spec.script)), settings);
+}
+function withDisplay(settings, opts) {
+  let next = withoutModDisplay(settings, opts.delimiter);
+  const statusLine = opts.display === "statusline" ? hookCommand(path5.join(opts.distDir, STATUSLINE_SCRIPT)) : null;
+  next = applyStatusLineDisplay(next, opts.home, statusLine);
+  if (opts.display === "mod") next = withModDisplay(next, path5.join(opts.distDir, "..", "mod"), dataDir(opts.home), opts.delimiter);
+  return next;
+}
+function save(home, settings, now) {
+  const file = settingsPath(home);
+  const backup = backupSettingsFile(file, backupsDir(home), now);
+  writeSettingsFile(file, settings);
+  return backup;
+}
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function install(opts) {
+  const delimiter = opts.delimiter ?? path5.delimiter;
+  const file = settingsPath(opts.home);
+  const before = readSettingsFile(file);
+  let next = before;
+  const installed = [];
+  const skipped = [];
+  let replacedLegacyRmGuard = false;
+  for (const feature of opts.features) {
+    const platforms = SUPPORTED_PLATFORMS[feature];
+    if (platforms && !platforms.includes(opts.platform)) {
+      skipped.push({ feature, reason: `${feature} works on ${platforms.join(", ")} only` });
+      continue;
+    }
+    for (const spec of HOOK_SPECS[feature]) {
+      if (!commandMatches(hookCommand(path5.join(opts.distDir, spec.script)), ownScriptPattern(spec.script))) {
+        throw new Error(`cannot install from ${opts.distDir}: the hook path must contain claude-jev-advisor/dist/`);
+      }
+    }
+    next = withoutFeature(next, feature);
+    if (feature === "rm" && findCommands(next, LEGACY_RM_GUARD).length) {
+      next = withoutCommands(next, LEGACY_RM_GUARD);
+      replacedLegacyRmGuard = true;
+    }
+    for (const spec of HOOK_SPECS[feature]) {
+      const command = hookCommand(path5.join(opts.distDir, spec.script), ...spec.args);
+      next = withHook(next, { event: spec.event, matcher: spec.matcher, command, timeout: HOOK_TIMEOUT_SECONDS });
+    }
+    installed.push(feature);
+  }
+  const display = installed.includes("context") ? opts.display ?? readConfig(opts.home).display : null;
+  if (display !== null) next = withDisplay(next, { home: opts.home, distDir: opts.distDir, display, delimiter });
+  const backup = same(before, next) ? null : save(opts.home, next, opts.now);
+  forgetStatusLineBefore(opts.home, next);
+  updateConfig(opts.home, (c) => ({
+    ...c,
+    lang: opts.lang ?? c.lang,
+    keyFile: opts.keyFile ?? c.keyFile,
+    display: opts.display ?? c.display,
+    rm: installed.includes("rm") ? { ...c.rm, enabled: true } : c.rm,
+    context: installed.includes("context") ? { ...c.context, enabled: true } : c.context
+  }));
+  return { settingsFile: file, backup, installed, skipped, replacedLegacyRmGuard, display };
+}
+function uninstall(opts) {
+  const delimiter = opts.delimiter ?? path5.delimiter;
+  const file = settingsPath(opts.home);
+  const before = readSettingsFile(file);
+  let next = before;
+  const removed = [];
+  for (const feature of opts.features) {
+    let after = withoutFeature(next, feature);
+    if (feature === "context") after = withDisplay(after, { home: opts.home, distDir: "", display: null, delimiter });
+    if (!same(after, next)) removed.push(feature);
+    next = after;
+  }
+  const backup = removed.length ? save(opts.home, next, opts.now) : null;
+  forgetStatusLineBefore(opts.home, next);
+  return { settingsFile: file, backup, removed };
+}
+function setEnabled(home, features, enabled) {
+  updateConfig(home, (c) => ({
+    ...c,
+    rm: features.includes("rm") ? { ...c.rm, enabled } : c.rm,
+    context: features.includes("context") ? { ...c.context, enabled } : c.context
+  }));
+}
+
+// src/status.ts
+import fs5 from "fs";
+import path6 from "path";
+
+// src/display/line.ts
+var PHRASES = {
+  ko: {
+    clear: "\uC0C8\uB86D\uAC8C \uC2DC\uC791\uD558\uB294 \uAC74 \uC5B4\uB5A0\uC138\uC694? /clear",
+    compact: "\uC9C0\uAE08\uAE4C\uC9C0 \uC815\uB9AC\uD558\uACE0 \uC774\uC5B4\uAC00\uB294 \uAC74 \uC5B4\uB5A0\uC138\uC694? /compact",
+    compactLater: "\uC791\uC5C5\uC774 \uB05D\uB098\uBA74 \uC815\uB9AC\uD558\uACE0 \uC774\uC5B4\uAC00\uB294 \uAC74 \uC5B4\uB5A0\uC138\uC694? /compact"
+  },
+  en: {
+    clear: "Start fresh? /clear",
+    compact: "Wrap up what you have and continue? /compact",
+    compactLater: "When this work is done, wrap up and continue? /compact"
+  }
+};
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatSize(tokens) {
+  return `${Math.round(tokens / 1e3)}k`;
+}
+function remainingPct(size, threshold) {
+  return Math.max(0, Math.round((threshold - size) / threshold * 100));
+}
+function adviceLine({ size, threshold, judgment, config }) {
+  if (size === null) return "";
+  const k = formatSize(size);
+  const phrases = PHRASES[config.lang];
+  const counted = size >= config.context.minTokens ? judgment : null;
+  if (threshold !== null && threshold > 0 && size >= threshold * (1 - config.context.redRemainingPct / 100)) {
+    const head = `\u{1F534} ${k} ${remainingPct(size, threshold)}%`;
+    if (!counted) return head;
+    if (counted.phase === "working") return `${head} \xB7 ${phrases.compactLater}`;
+    return `${head} \xB7 ${counted.clear ? phrases.clear : phrases.compact}`;
+  }
+  if (!counted) return k;
+  if (counted.phase === "working") return `\u{1F7E2} ${k}`;
+  if (counted.clear) return `\u{1F7E1} ${k} ${phrases.clear}`;
+  if (size >= config.context.compactMinTokens) return `\u{1F7E1} ${k} ${phrases.compact}`;
+  return `\u{1F7E2} ${k}`;
+}
+function parseState(raw) {
+  if (!isRecord3(raw) || typeof raw.sessionId !== "string" || typeof raw.at !== "number") return null;
+  const j = raw.judgment;
+  const judgment = isRecord3(j) && (j.phase === "working" || j.phase === "unit_done") && typeof j.clear === "boolean" ? { phase: j.phase, clear: j.clear } : null;
+  return { sessionId: raw.sessionId, at: raw.at, size: typeof raw.size === "number" ? raw.size : null, judgment };
+}
+
+// src/jev.ts
+import fs4 from "fs";
+var KEY_PREFIX = "TYPESAFE_API_KEY=";
+function readJevKey(env, keyFile) {
+  const fromEnv = env.TYPESAFE_API_KEY?.trim();
+  if (fromEnv) return fromEnv;
+  if (!keyFile) return null;
+  let text;
+  try {
+    text = fs4.readFileSync(keyFile, "utf8");
+  } catch {
+    return null;
+  }
+  const line = text.replace(/^\uFEFF/, "").split(/\r?\n/).find((l) => l.startsWith(KEY_PREFIX));
+  const key = line?.slice(KEY_PREFIX.length).trim().replace(/^["']|["']$/g, "");
+  return key || null;
+}
+
+// src/status.ts
+var SCRIPT_IN_COMMAND = /^node "([^"]+)"/;
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function displaySetUp(settings, config) {
+  if (config.display === "message") return true;
+  if (config.display === "statusline") return isOurStatusLine(settings.statusLine);
+  const env = isRecord4(settings.env) ? settings.env : {};
+  const dirs = typeof env[PLUGIN_DIRS_ENV] === "string" ? env[PLUGIN_DIRS_ENV] : "";
+  const hasDir = dirs.split(path6.delimiter).some((dir) => MOD_DIR_PATTERN.test(dir.replace(/\\/g, "/")));
+  return hasDir && isRecord4(settings.pluginConfigs) && MOD_PLUGIN_NAME in settings.pluginConfigs;
+}
+function newestState(home) {
+  let newest = null;
+  try {
+    for (const name of fs5.readdirSync(stateDir(home))) {
+      if (!name.endsWith(".json")) continue;
+      const file = path6.join(stateDir(home), name);
+      const mtime = fs5.statSync(file).mtimeMs;
+      if (!newest || mtime > newest.mtime) newest = { file, mtime };
+    }
+    return newest ? parseState(JSON.parse(fs5.readFileSync(newest.file, "utf8"))) : null;
+  } catch {
+    return null;
+  }
+}
+function contextLines(home, settings, config, env) {
+  const c = config.context;
+  const lines = [
+    `  display: ${config.display}${displaySetUp(settings, config) ? "" : ` (not set up in settings.json - run "claude-jev-advisor install context --display ${config.display}")`}`,
+    `  key: ${readJevKey(env, config.keyFile) ? "set" : "missing"}`,
+    `  thresholds: judge from ${formatSize(c.minTokens)}, /compact from ${formatSize(c.compactMinTokens)}, red at ${c.redRemainingPct}% left`
+  ];
+  const last = newestState(home);
+  if (last) {
+    const line = adviceLine({ size: last.size, threshold: null, judgment: last.judgment, config }) || "(no size)";
+    lines.push(`  last judgment: ${new Date(last.at).toISOString()} ${line}`);
+  }
+  return lines;
+}
+function statusLines(home, env = process.env) {
+  const lines = [`settings: ${settingsPath(home)}`, `config:   ${configPath(home)}`];
+  let settings;
+  try {
+    settings = readSettingsFile(settingsPath(home));
+  } catch (err) {
+    return [...lines, `settings.json could not be read: ${err.message}`];
+  }
+  const config = readConfig(home);
+  for (const feature of FEATURES) {
+    const state = config[feature].enabled ? "on" : "off";
+    const commands = HOOK_SPECS[feature].flatMap((spec) => findCommands(settings, ownScriptPattern(spec.script)));
+    if (!commands.length) {
+      lines.push(`${feature}: not installed (${state})`);
+      continue;
+    }
+    lines.push(`${feature}: installed, ${state}`);
+    for (const c of commands) {
+      const script = SCRIPT_IN_COMMAND.exec(c.command)?.[1];
+      if (script && !fs5.existsSync(script)) {
+        lines.push(`  broken: ${c.event} hook points to a missing file (${script}) - run "claude-jev-advisor install ${feature}" again, or "claude-jev-advisor uninstall ${feature}"`);
+      }
+    }
+    if (feature === "context") lines.push(...contextLines(home, settings, config, env));
+  }
+  if (findCommands(settings, LEGACY_RM_GUARD).length) {
+    lines.push('legacy rm-guard hook (~/.claude/hooks/rm-guard) is still registered - "claude-jev-advisor install rm" replaces it');
+  }
+  return lines;
+}
+
+// src/cli/run.ts
+var USAGE = [
+  "Usage: claude-jev-advisor <command> [helpers] [options]",
+  "",
+  "Commands:",
+  "  install [rm] [context]     register hooks in ~/.claude/settings.json (backs it up first)",
+  "  uninstall [rm] [context]   remove this package's hooks and display from ~/.claude/settings.json",
+  "  on [rm] [context]          switch helpers on (open sessions too)",
+  "  off [rm] [context]         switch helpers off (open sessions too)",
+  "  status                     show what is registered and switched on",
+  "",
+  "Options for install: --lang ko|en  --key-file <path>  --display mod|statusline|message",
+  'The display is set up when context is installed: "install context --display <mode>" switches it.',
+  "Leaving out the helpers means all of them.",
+  'Run "claude-jev-advisor uninstall" before "npm rm -g": npm does not run uninstall scripts.'
+].join("\n");
+var INSTALL_OPTIONS = ["lang", "key-file", "display"];
+var LANGS2 = ["ko", "en"];
+var DISPLAYS2 = ["mod", "statusline", "message"];
+function parse(argv) {
+  const [command = "help", ...rest] = argv;
+  const features = [];
+  const options = {};
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg.startsWith("--")) {
+      const value = rest[i + 1];
+      if (value === void 0 || value.startsWith("--")) return `${arg} needs a value`;
+      options[arg.slice(2)] = value;
+      i++;
+    } else if (isFeature(arg)) {
+      if (!features.includes(arg)) features.push(arg);
+    } else {
+      return `unknown helper "${arg}" (known: ${FEATURES.join(", ")})`;
+    }
+  }
+  return { command, features: features.length ? features : [...FEATURES], options };
+}
+function checkOptions(command, options) {
+  const names = Object.keys(options);
+  if (command !== "install") return names.length ? `options are only for install (got --${names[0]})` : null;
+  const unknown = names.find((n) => !INSTALL_OPTIONS.includes(n));
+  if (unknown) return `unknown option --${unknown}`;
+  if (options.lang !== void 0 && !LANGS2.includes(options.lang)) return "--lang takes ko or en";
+  if (options.display !== void 0 && !DISPLAYS2.includes(options.display)) return "--display takes mod, statusline or message";
+  return null;
+}
+function runCli(argv, io) {
+  const parsed = parse(argv);
+  const problem = typeof parsed === "string" ? parsed : checkOptions(parsed.command, parsed.options);
+  if (typeof parsed === "string" || problem) {
+    io.err(problem ?? String(parsed));
+    io.err(USAGE);
+    return 2;
+  }
+  const { command, features, options } = parsed;
+  try {
+    switch (command) {
+      case "install": {
+        const r = install({
+          home: io.home,
+          features,
+          distDir: io.distDir,
+          platform: io.platform,
+          now: io.now(),
+          lang: options.lang,
+          keyFile: options["key-file"] === void 0 || path7.isAbsolute(options["key-file"]) ? options["key-file"] : path7.resolve(options["key-file"]),
+          display: options.display
+        });
+        for (const f of r.installed) io.out(`installed ${f}`);
+        for (const s of r.skipped) io.out(`skipped ${s.feature}: ${s.reason}`);
+        if (r.replacedLegacyRmGuard) io.out("replaced the legacy rm-guard hook (its files under ~/.claude/hooks/rm-guard were left in place)");
+        if (r.display) io.out(`display: ${r.display}`);
+        if (r.backup) io.out(`backup: ${r.backup}`);
+        if (r.installed.length) io.out("Hooks apply to Claude Code sessions started from now on.");
+        return 0;
+      }
+      case "uninstall": {
+        const r = uninstall({ home: io.home, features, now: io.now() });
+        if (!r.removed.length) io.out("nothing to remove");
+        for (const f of r.removed) io.out(`removed ${f}`);
+        if (r.backup) io.out(`backup: ${r.backup}`);
+        return 0;
+      }
+      case "on":
+      case "off":
+        setEnabled(io.home, features, command === "on");
+        io.out(`${features.join(", ")}: ${command}`);
+        return 0;
+      case "status":
+        for (const line of statusLines(io.home)) io.out(line);
+        return 0;
+      case "help":
+      case "--help":
+      case "-h":
+        io.out(USAGE);
+        return 0;
+      default:
+        io.err(`unknown command "${command}"`);
+        io.err(USAGE);
+        return 2;
+    }
+  } catch (err) {
+    io.err(`claude-jev-advisor: ${err.message}`);
+    return 1;
+  }
+}
+
+// src/cli.ts
+process.exitCode = runCli(process.argv.slice(2), {
+  home: os.homedir(),
+  distDir: path8.dirname(fileURLToPath(import.meta.url)),
+  platform: process.platform,
+  now: () => /* @__PURE__ */ new Date(),
+  out: (line) => console.log(line),
+  err: (line) => console.error(line)
+});