@delt/claude-jev-advisor 0.1.0

package/dist/rm-hook.js

@@ -0,0 +1,437 @@
+#!/usr/bin/env node
+
+// src/rm/hook.ts
+import os from "os";
+
+// src/rm/guard.ts
+import fs from "fs";
+import path from "path";
+import { spawnSync } from "child_process";
+var win = path.win32;
+var SEPARATORS = /* @__PURE__ */ new Set([";", "&&", "||", "|", "|&", "&", "(", ")"]);
+var SKIP_WORDS = /* @__PURE__ */ new Set(["then", "else", "elif", "do", "while", "until", "if", "!", "{", "time"]);
+var HEADER_WORDS = /* @__PURE__ */ new Set(["for", "select", "case"]);
+var CLOSING_WORDS = /* @__PURE__ */ new Set(["done", "fi", "esac", "}"]);
+var BUILD_DIRS = /* @__PURE__ */ new Set(["target", "build", "dist", "out", "node_modules", "coverage", "__pycache__", ".pytest_cache", ".gradle", ".next", ".nuxt", ".turbo", ".cache", "bin", "obj"]);
+var MAX_LISTED = 3;
+var ASSIGNMENT = /^([A-Za-z_][A-Za-z0-9_]*)=/;
+var DECLARERS = /* @__PURE__ */ new Set(["export", "readonly", "declare", "typeset", "local"]);
+var KNOWN_ENV = ["TEMP", "TMP", "TMPDIR", "HOME", "USERPROFILE"];
+function stripHeredocs(text) {
+  const out = [];
+  const pending = [];
+  for (const line of text.split("\n")) {
+    if (pending.length) {
+      const { dash, word } = pending[0];
+      if ((dash ? line.replace(/^\t+/, "") : line).trimEnd() === word) pending.shift();
+      continue;
+    }
+    out.push(line);
+    for (const m of line.matchAll(/(?<!<)<<(?!<)(-?)\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\2/g)) pending.push({ dash: m[1] === "-", word: m[3] });
+  }
+  return out.join("\n");
+}
+function tokenize(text) {
+  const tokens = [];
+  let i = 0;
+  let word = null;
+  let skipNextWord = false;
+  const start = () => word ??= { value: "", dynamic: false, glob: false, tilde: false, brace: false };
+  const finish = () => {
+    if (word === null) return;
+    if (skipNextWord) skipNextWord = false;
+    else tokens.push({ type: "word", ...word });
+    word = null;
+  };
+  const readBalanced = (open, close) => {
+    let depth = 0;
+    const from = i;
+    for (; i < text.length; i++) {
+      if (text[i] === open) depth++;
+      else if (text[i] === close && --depth === 0) {
+        i++;
+        return text.slice(from, i);
+      }
+    }
+    return text.slice(from);
+  };
+  const readDollar = () => {
+    const w = start();
+    w.dynamic = true;
+    if (text[i + 1] === "(") {
+      w.value += "$";
+      i++;
+      w.value += readBalanced("(", ")");
+      return;
+    }
+    if (text[i + 1] === "{") {
+      w.value += "$";
+      i++;
+      w.value += readBalanced("{", "}");
+      return;
+    }
+    const m = /^\$([A-Za-z_][A-Za-z0-9_]*|[0-9@*#?$!-])/.exec(text.slice(i));
+    if (m) {
+      w.value += m[0];
+      i += m[0].length;
+      return;
+    }
+    w.dynamic = false;
+    w.value += "$";
+    i++;
+  };
+  while (i < text.length) {
+    const c = text[i];
+    if (c === " " || c === "	" || c === "\r") {
+      finish();
+      i++;
+      continue;
+    }
+    if (c === "\n") {
+      finish();
+      tokens.push({ type: "op", value: ";" });
+      i++;
+      continue;
+    }
+    if (c === "#" && word === null) {
+      while (i < text.length && text[i] !== "\n") i++;
+      continue;
+    }
+    if (c === "'") {
+      const end = text.indexOf("'", i + 1);
+      start().value += text.slice(i + 1, end === -1 ? text.length : end);
+      i = end === -1 ? text.length : end + 1;
+      continue;
+    }
+    if (c === '"') {
+      const w2 = start();
+      i++;
+      while (i < text.length && text[i] !== '"') {
+        if (text[i] === "\\" && '"\\$`'.includes(text[i + 1] ?? "")) {
+          w2.value += text[i + 1];
+          i += 2;
+          continue;
+        }
+        if (text[i] === "$") {
+          readDollar();
+          continue;
+        }
+        if (text[i] === "`") {
+          w2.dynamic = true;
+          const end = text.indexOf("`", i + 1);
+          w2.value += text.slice(i, end === -1 ? text.length : end + 1);
+          i = end === -1 ? text.length : end + 1;
+          continue;
+        }
+        w2.value += text[i++];
+      }
+      i++;
+      continue;
+    }
+    if (c === "\\") {
+      start().value += text[i + 1] ?? "";
+      i += 2;
+      continue;
+    }
+    if (c === "$") {
+      readDollar();
+      continue;
+    }
+    if (c === "`") {
+      const w2 = start();
+      w2.dynamic = true;
+      const end = text.indexOf("`", i + 1);
+      w2.value += text.slice(i, end === -1 ? text.length : end + 1);
+      i = end === -1 ? text.length : end + 1;
+      continue;
+    }
+    if (c === ">" || c === "<" || c === "&" && text[i + 1] === ">") {
+      if (word !== null && /^\d+$/.test(word.value) && !word.dynamic) word = null;
+      else finish();
+      const m = /^(&>>?|\d*[<>]+[&|]?)/.exec(text.slice(i));
+      i += m[0].length;
+      if (/&$/.test(m[0]) && /^\d|^-/.test(text[i] ?? "")) {
+        while (i < text.length && /[\d-]/.test(text[i])) i++;
+        continue;
+      }
+      skipNextWord = true;
+      continue;
+    }
+    const op = ["&&", "||", "|&", ";;", ";", "|", "&", "(", ")"].find((o) => text.startsWith(o, i));
+    if (op) {
+      finish();
+      tokens.push({ type: "op", value: op === ";;" ? ";" : op });
+      i += op.length;
+      continue;
+    }
+    const w = start();
+    if (c === "~" && w.value === "") w.tilde = true;
+    if ("*?[".includes(c)) w.glob = true;
+    if (c === "{" && /^\{[^}]*,[^}]*\}/.test(text.slice(i))) w.brace = true;
+    w.value += c;
+    i++;
+  }
+  finish();
+  return tokens;
+}
+function splitCommands(tokens) {
+  const commands = [];
+  let current = [];
+  for (const t of tokens) {
+    if (t.type === "op" && SEPARATORS.has(t.value)) {
+      commands.push({ words: current, after: t.value });
+      current = [];
+    } else if (t.type === "word") current.push(t);
+  }
+  commands.push({ words: current, after: null });
+  return commands;
+}
+function expand(word, vars) {
+  if (!word.dynamic) return word.value;
+  let known = true;
+  const out = word.value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (m, braced, bare) => {
+    const v = vars.get(braced ?? bare ?? "");
+    if (typeof v !== "string") {
+      known = false;
+      return m;
+    }
+    return v;
+  });
+  return known && !/[$`]/.test(out) ? out : null;
+}
+function assign(word, vars, home) {
+  const name = ASSIGNMENT.exec(word.value)[1];
+  let value = expand({ value: word.value.slice(name.length + 1), dynamic: word.dynamic }, vars);
+  if (value !== null && /^~(?:[\\/]|$)/.test(value)) value = home + value.slice(1);
+  vars.set(name, value);
+}
+function commandName(word) {
+  if (word.dynamic) return null;
+  return win.basename(word.value.replace(/\//g, "\\")).replace(/\.exe$/i, "").toLowerCase();
+}
+function stripPrefixes(words) {
+  let rest = words;
+  for (; ; ) {
+    while (rest.length && ASSIGNMENT.test(rest[0].value)) rest = rest.slice(1);
+    if (!rest.length) return rest;
+    const name = commandName(rest[0]);
+    if (SKIP_WORDS.has(rest[0].value) || name === "command" || name === "builtin" || name === "exec" || name === "nohup") {
+      rest = rest.slice(1);
+      continue;
+    }
+    if (name === "sudo" || name === "env") {
+      rest = rest.slice(1);
+      while (rest.length && !rest[0].dynamic && rest[0].value.startsWith("-")) rest = rest.slice(1);
+      continue;
+    }
+    if (name === "timeout") {
+      rest = rest.slice(1);
+      while (rest.length && !rest[0].dynamic && rest[0].value.startsWith("-")) rest = rest.slice(1);
+      rest = rest.slice(1);
+      continue;
+    }
+    return rest;
+  }
+}
+function toWindowsPath(word, cwd, home, tmpdir) {
+  const v = word.value;
+  if (word.tilde && (v === "~" || v.startsWith("~/") || v.startsWith("~\\"))) return { path: win.resolve(home, v.slice(2) || ".") };
+  if (/^[A-Za-z]:[\\/]/.test(v)) return { path: win.normalize(v) };
+  const drive = /^\/([A-Za-z])(?:\/(.*))?$/.exec(v);
+  if (drive) return { path: win.normalize(`${drive[1].toUpperCase()}:\\${drive[2] ?? ""}`) };
+  const tmp = /^\/tmp(?:\/(.*))?$/.exec(v);
+  if (tmp) return { path: win.resolve(tmpdir, tmp[1] ?? ".") };
+  if (v.startsWith("/")) return { unknown: v };
+  if (cwd === null) return { unresolvable: "a relative path after cd to a path that cannot be worked out" };
+  return { path: win.resolve(cwd, v) };
+}
+function isInside(child, parent) {
+  const c = child.toLowerCase();
+  const p = parent.toLowerCase().replace(/\\+$/, "");
+  return c.startsWith(`${p}\\`);
+}
+function segments(p) {
+  return p.toLowerCase().split("\\");
+}
+function classify(target, ctx) {
+  if (target.brace) return { unresolvable: `brace expansion (${target.value})` };
+  const value = expand(target, ctx.vars);
+  if (value === null) return { unresolvable: `a shell variable or command substitution that cannot be worked out (${target.value})` };
+  let w = { ...target, value, dynamic: false };
+  let pattern = null;
+  if (target.glob) {
+    const parts = value.split(/[\\/]/);
+    if (parts.slice(0, -1).some((s) => /[*?[]/.test(s))) return { unresolvable: `a wildcard in a folder name (${target.value})` };
+    pattern = parts[parts.length - 1];
+    w = { ...w, value: parts.slice(0, -1).join("/") || "." };
+  }
+  const resolved = toWindowsPath(w, ctx.cwd, ctx.home, ctx.tmpdirs[0]);
+  if (resolved.unresolvable) return { unresolvable: resolved.unresolvable };
+  if (resolved.unknown) return { real: target.value };
+  const p = resolved.path;
+  const shown = pattern === null ? p : `${p}\\${pattern}`;
+  const narrowPattern = pattern !== null && !/^[*?.]+$/.test(pattern);
+  if (ctx.tmpdirs.some((t) => isInside(p, t) || narrowPattern && p.toLowerCase() === t.toLowerCase().replace(/\\+$/, ""))) return {};
+  if (segments(p).includes(".superpowers")) return {};
+  if (pattern === null && !ctx.probe.exists(p)) return {};
+  if (segments(p).some((s) => BUILD_DIRS.has(s)) && ctx.probe.isIgnored(p)) return {};
+  return { real: shown };
+}
+function deny(why) {
+  return {
+    decision: "deny",
+    reason: `rm-guard could not work out what this rm would delete (${why}). Rewrite it with literal paths: no shell variables, command substitutions, xargs, brace expansion or wildcards in folder names, and no cd to such a path before it. Example: rm -f "C:/full/path/file.txt". If you need a variable or a listing to find the paths, run that on its own first, then rm the printed paths.`
+  };
+}
+function decide({ command, cwd, home, tmpdirs, env = {}, probe }) {
+  if (!/\b(?:rm|rmdir|xargs)\b/.test(command)) return null;
+  const commands = splitCommands(tokenize(stripHeredocs(command)));
+  const vars = new Map(KNOWN_ENV.filter((n) => env[n]).map((n) => [n, env[n]]));
+  const ctx = { cwd, home, tmpdirs, probe, vars };
+  const setCwd = (next) => {
+    ctx.cwd = next;
+    vars.set("PWD", next);
+  };
+  setCwd(cwd);
+  const stack = [];
+  const real = [];
+  for (const { words, after } of commands) {
+    const rest = stripPrefixes(words);
+    if (!rest.length) {
+      for (const w of words) if (ASSIGNMENT.test(w.value)) assign(w, vars, home);
+    } else if (HEADER_WORDS.has(rest[0].value)) {
+      if (rest[0].value !== "case" && rest[1]) vars.set(rest[1].value, null);
+    } else if (!CLOSING_WORDS.has(rest[0].value)) {
+      const name = commandName(rest[0]);
+      if (name !== null && DECLARERS.has(name)) {
+        for (const w of rest.slice(1)) if (ASSIGNMENT.test(w.value)) assign(w, vars, home);
+      } else if (name === "cd" || name === "pushd" || name === "popd") {
+        const arg = rest[1];
+        const value = arg ? expand(arg, vars) : null;
+        if (name === "popd" || arg && (value === null || value === "-")) setCwd(null);
+        else if (!arg) setCwd(home);
+        else setCwd(toWindowsPath({ ...arg, value }, ctx.cwd, home, tmpdirs[0]).path ?? null);
+      } else if (name === "xargs") {
+        if (rest.slice(1).some((t) => {
+          const n = commandName(t);
+          return n === "rm" || n === "rmdir";
+        })) {
+          return deny("xargs feeding rm");
+        }
+      } else if (name === "rm" || name === "rmdir") {
+        let options = true;
+        for (const t of rest.slice(1)) {
+          if (options && !t.dynamic && t.value === "--") {
+            options = false;
+            continue;
+          }
+          if (options && !t.dynamic && t.value.length > 1 && t.value.startsWith("-")) continue;
+          const c = classify(t, ctx);
+          if (c.unresolvable) return deny(c.unresolvable);
+          if (c.real) real.push(c.real);
+        }
+      }
+    }
+    if (after === "(") stack.push(ctx.cwd);
+    if (after === ")" && stack.length) setCwd(stack.pop() ?? null);
+  }
+  if (!real.length) return null;
+  const listed = real.slice(0, MAX_LISTED).join(", ");
+  const more = real.length > MAX_LISTED ? ` \uC678 ${real.length - MAX_LISTED}\uAC1C` : "";
+  return { decision: "ask", reason: `\uC2E4\uC81C \uD30C\uC77C \uC0AD\uC81C: ${listed}${more}` };
+}
+function hookOutput({ decision, reason }) {
+  return JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: decision, permissionDecisionReason: reason } });
+}
+var realProbe = {
+  exists(p) {
+    try {
+      fs.lstatSync(p);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  isIgnored(p) {
+    const r = spawnSync("git", ["-C", win.dirname(p), "check-ignore", "-q", "--", p], { timeout: 3e3, windowsHide: true });
+    return r.status === 0;
+  }
+};
+
+// src/rm/run.ts
+import path4 from "path";
+
+// src/config.ts
+import fs2 from "fs";
+import path3 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 path2 from "path";
+var claudeDir = (home) => path2.join(home, ".claude");
+var dataDir = (home) => path2.join(claudeDir(home), "claude-jev-advisor");
+var configPath = (home) => path2.join(dataDir(home), "config.json");
+
+// src/config.ts
+function readConfig(home) {
+  try {
+    return normalizeConfig(JSON.parse(fs2.readFileSync(configPath(home), "utf8").replace(/^\uFEFF/, "")));
+  } catch {
+    return normalizeConfig({});
+  }
+}
+
+// src/rm/run.ts
+function runRmHook(raw, deps) {
+  if (!readConfig(deps.home).rm.enabled) return null;
+  const input = JSON.parse(raw);
+  if (typeof input !== "object" || input === null) return null;
+  const command = input.tool_input?.command;
+  if (input.tool_name !== "Bash" || typeof command !== "string") return null;
+  const tmpdirs = [...new Set([deps.tmpdir, deps.env.TEMP, deps.env.TMP].filter((t) => Boolean(t)).map((t) => path4.win32.resolve(t)))];
+  const cwd = typeof input.cwd === "string" && input.cwd ? input.cwd : deps.cwd;
+  const result = decide({ command, cwd, home: deps.home, tmpdirs, env: deps.env, probe: deps.probe });
+  return result ? hookOutput(result) : null;
+}
+
+// src/rm/hook.ts
+async function main() {
+  let raw = "";
+  process.stdin.setEncoding("utf8");
+  for await (const chunk of process.stdin) raw += chunk;
+  const out = runRmHook(raw, { home: os.homedir(), env: process.env, tmpdir: os.tmpdir(), cwd: process.cwd(), probe: realProbe });
+  if (out) process.stdout.write(out);
+}
+main().catch(() => {
+});

package/dist/statusline.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+// src/display/statusline.ts
+import os from "os";
+
+// src/display/statusline-run.ts
+import { spawnSync } from "child_process";
+import fs3 from "fs";
+
+// 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 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({});
+  }
+}
+
+// src/context/files.ts
+import fs2 from "fs";
+import path3 from "path";
+
+// src/display/line.ts
+var STALE_SIZE_RATIO = 0.7;
+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 isRecord2(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 usableJudgment(state, liveSize, turnStartedAt) {
+  if (!state || !state.judgment || state.at < turnStartedAt) return null;
+  if (liveSize !== null && state.size !== null && liveSize < state.size * STALE_SIZE_RATIO) return null;
+  return state.judgment;
+}
+function parseState(raw) {
+  if (!isRecord2(raw) || typeof raw.sessionId !== "string" || typeof raw.at !== "number") return null;
+  const j = raw.judgment;
+  const judgment = isRecord2(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/context/files.ts
+var SAFE_SESSION_ID = /^[A-Za-z0-9_-]+$/;
+function statePath(home, sessionId) {
+  return SAFE_SESSION_ID.test(sessionId) ? path3.join(stateDir(home), `${sessionId}.json`) : null;
+}
+function readState(home, sessionId) {
+  const file = statePath(home, sessionId);
+  if (!file) return null;
+  try {
+    return parseState(JSON.parse(fs2.readFileSync(file, "utf8")));
+  } catch {
+    return null;
+  }
+}
+
+// src/display/statusline-run.ts
+var BEFORE_TIMEOUT_MS = 2e3;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function previousStatusLine(home) {
+  try {
+    const value = JSON.parse(fs3.readFileSync(statusLineBeforePath(home), "utf8"));
+    return isRecord3(value) && typeof value.command === "string" ? { command: value.command } : null;
+  } catch {
+    return null;
+  }
+}
+function runBeforeCommand(command, input) {
+  const r = spawnSync(command, { shell: true, input, encoding: "utf8", timeout: BEFORE_TIMEOUT_MS, windowsHide: true });
+  return r.status === 0 && typeof r.stdout === "string" ? r.stdout : "";
+}
+function ourLine(raw, home) {
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    return "";
+  }
+  const config = readConfig(home);
+  if (!isRecord3(input) || typeof input.session_id !== "string" || !config.context.enabled || config.display !== "statusline") return "";
+  const window = isRecord3(input.context_window) ? input.context_window : {};
+  const size = typeof window.total_input_tokens === "number" && window.total_input_tokens > 0 ? window.total_input_tokens : null;
+  const judgment = usableJudgment(readState(home, input.session_id), size, 0);
+  return adviceLine({ size, threshold: null, judgment, config });
+}
+function runStatusLine(raw, deps) {
+  const before = previousStatusLine(deps.home);
+  const parts = [before ? deps.runBefore(before.command, raw).replace(/\s+$/, "") : "", ourLine(raw, deps.home)];
+  return parts.filter(Boolean).join(" ");
+}
+
+// src/display/statusline.ts
+async function main() {
+  let raw = "";
+  process.stdin.setEncoding("utf8");
+  for await (const chunk of process.stdin) raw += chunk;
+  const out = runStatusLine(raw, { home: os.homedir(), runBefore: runBeforeCommand });
+  if (out) process.stdout.write(out);
+}
+main().catch(() => {
+});

package/mod/.claude-plugin/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "jev-advisor",
+  "version": "0.1.0",
+  "description": "Bottom-row compact/clear advice from @delt/claude-jev-advisor (unofficial)",
+  "author": { "name": "delt96" },
+  "userConfig": {
+    "dataDir": {
+      "type": "string",
+      "title": "Data folder",
+      "description": "The claude-jev-advisor data folder holding config.json and state/. Set by claude-jev-advisor install.",
+      "default": ""
+    }
+  }
+}

package/mod/hooks/hooks.json

@@ -0,0 +1 @@
+{ "modules": ["./register.js"] }