@delt/claude-jev-advisor 0.1.0 → 0.1.2

package/README.md

@@ -27,10 +27,10 @@ npm i -g @delt/claude-jev-advisor
 Then register the hooks:
 
 ```bash
-claude-jev-advisor install --key-file C:/path/to/jev-key.env
+claude-jev-advisor install
 ```
 
-The key file holds a line `TYPESAFE_API_KEY=...`. Only its path is saved, never the key.
+When the context helper is installed and no key is found, `install` asks for your TypeSafe API key. What you type is hidden. It checks the key with one small Jev call and saves it to `~/.claude/claude-jev-advisor/jev-key.env`. Press Enter to skip; `claude-jev-advisor key` asks again later. Instead of typing it, you can set `TYPESAFE_API_KEY`, or pass `--key-file <path>` to a file holding a line `TYPESAFE_API_KEY=...` (then only that path is saved). The key is never printed or logged. On Windows that file is protected by your user folder's permissions only.
 
 Before it changes `~/.claude/settings.json`, `install` copies it to `~/.claude/backups/settings.json.<YYYY-MM-DD-HHmmss>-before-claude-jev-advisor`. If a backup from the same second already exists, it adds `-2`, `-3` and so on instead of overwriting it. It then adds or replaces only this package's entries. Running it again changes nothing.
 
@@ -44,6 +44,7 @@ The hooks also reach Claude Code sessions that are already open; the bottom-row
 | `claude-jev-advisor uninstall [rm] [context]` | Removes this package's hooks and display from `settings.json` |
 | `claude-jev-advisor on [rm] [context]` / `off [rm] [context]` | Switches helpers on or off without touching `settings.json` |
 | `claude-jev-advisor status` | Shows what is registered and on, the display, whether a key is set, the thresholds and the last judgment |
+| `claude-jev-advisor key` | Asks for the TypeSafe API key, checks it and saves it (needs an interactive terminal) |
 | `claude-jev-advisor help` | Prints the usage |
 
 If you leave out the helper names, the command applies to all helpers. The display is set up when `context` is installed; run `claude-jev-advisor install context --display <mode>` to switch it.
@@ -98,6 +99,20 @@ A target cannot be worked out when it uses:
 - a wildcard in a folder name
 - a `cd` to such a path earlier in the command
 
+It does not see deletions made any other way:
+
+- through the PowerShell tool (`Remove-Item` and its aliases). On Windows with Git Bash installed, Claude Code turns this tool on by default for claude.ai and Console accounts and uses PowerShell as its main shell, so many deletions go through it.
+- through a nested shell: `sh -c`, `bash -c`, `powershell -Command`, `pwsh -c`, `cmd /c del`
+- with other commands or programs, such as `find -delete`, `git clean` or a script that deletes files
+
+What its decisions do depends on Claude Code's permission mode:
+
+| Mode | `ask` | `deny` | No decision |
+|---|---|---|---|
+| `auto` | A prompt. The auto mode classifier can still block the call but cannot approve it on its own (Claude Code 2.1.211 or later). | Blocked | The classifier decides |
+| `bypassPermissions` | A prompt. Claude Code's documentation does not say this; it was seen in a test on 2026-10-03. | Blocked | Runs |
+| Other modes | A prompt (`dontAsk` refuses the call instead) | Blocked | Claude Code's normal permission handling |
+
 `install rm` also replaces an older personal hook at `~/.claude/hooks/rm-guard/rm-guard.mjs` if one is registered. Its files are left in place.
 
 If a hook of this package fails in any way, it prints nothing and exits 0, so it never blocks Claude Code.
@@ -113,6 +128,8 @@ npm rm -g @delt/claude-jev-advisor
 
 If the package is removed first, the hook entries point to a missing file. Claude Code keeps running, but the helpers are off. To clean up, reinstall the package and run `claude-jev-advisor uninstall`, or delete the entries from `settings.json` by hand.
 
+A key saved by `install` or `key` stays in `~/.claude/claude-jev-advisor/jev-key.env`; delete that file if you no longer need it.
+
 ## Files
 
 | Path | Contents |
@@ -121,6 +138,7 @@ If the package is removed first, the hook entries point to a missing file. Claud
 | `~/.claude/claude-jev-advisor/state/<session>.json` | The last judgment of each open session, read by the display. Removed when the session ends. |
 | `~/.claude/claude-jev-advisor/log/YYYY-MM.jsonl` | One line per judgment: the size, what was sent to Jev (parts of your conversation), the answers and the result. Never the key. |
 | `~/.claude/claude-jev-advisor/statusline-before.json` | Your own status line while `--display statusline` is in use |
+| `~/.claude/claude-jev-advisor/jev-key.env` | Your TypeSafe API key, when you typed it in `install` or `key` |
 | `~/.claude/backups/settings.json.*-before-claude-jev-advisor` | Copies of `settings.json` from before each change |
 
 Default config:

package/dist/cli.js

@@ -2,39 +2,77 @@
 
 // src/cli.ts
 import os from "os";
-import path8 from "path";
+import path9 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/cli/prompt.ts
+var ENTER = /* @__PURE__ */ new Set([10, 13]);
+var BACKSPACE = /* @__PURE__ */ new Set([8, 127]);
+var CTRL_C = 3;
+var ESC = 27;
+var ERASE = `${String.fromCharCode(8)} ${String.fromCharCode(8)}`;
+var PROCESS_TERMINAL = { stdin: process.stdin, stdout: process.stdout, exit: (code) => process.exit(code) };
+function terminalPrompt(terminal = PROCESS_TERMINAL) {
+  const { stdin, stdout, exit } = terminal;
+  if (!stdin.isTTY || !stdout.isTTY) return void 0;
+  return {
+    ask: (question) => new Promise((resolve) => {
+      stdout.write(question);
+      let value = "";
+      let inEscape = false;
+      const stop = () => {
+        stdin.removeListener("data", onData);
+        stdin.removeListener("end", onEnd);
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdout.write("\n");
+      };
+      const onEnd = () => {
+        stop();
+        resolve("");
+      };
+      const onData = (chunk) => {
+        for (const ch of chunk) {
+          const code = ch.charCodeAt(0);
+          if (inEscape) {
+            if (ch !== "[" && code >= 64 && code <= 126) inEscape = false;
+            continue;
+          }
+          if (code === ESC) {
+            inEscape = true;
+          } else if (ENTER.has(code)) {
+            stop();
+            resolve(value);
+            return;
+          } else if (code === CTRL_C) {
+            stop();
+            exit(130);
+            return;
+          } else if (BACKSPACE.has(code)) {
+            if (value) stdout.write(ERASE);
+            value = Array.from(value).slice(0, -1).join("");
+          } else if (code >= 32) {
+            value += ch;
+            stdout.write("*");
+          }
+        }
+      };
+      stdin.setEncoding("utf8");
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.on("data", onData);
+      stdin.on("end", onEnd);
+    }),
+    say: (line) => {
+      stdout.write(`${line}
+`);
+    }
+  };
 }
 
-// src/install.ts
-import path5 from "path";
+// src/cli/run.ts
+import fs7 from "fs";
+import path8 from "path";
 
 // src/config.ts
 import fs from "fs";
@@ -81,6 +119,7 @@ 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");
+var savedKeyPath = (home) => path.join(dataDir(home), "jev-key.env");
 
 // src/config.ts
 function readConfig(home) {
@@ -102,6 +141,34 @@ function updateConfig(home, change) {
   return next;
 }
 
+// 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/display/settings.ts
 import fs2 from "fs";
 import path3 from "path";
@@ -383,9 +450,107 @@ function setEnabled(home, features, enabled) {
   }));
 }
 
-// src/status.ts
+// src/jev.ts
+import fs4 from "fs";
+var JEV_URL = "https://api.typesafe.ai/v1/systemone";
+var JEV_TIMEOUT_MS = 8e3;
+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;
+}
+async function callJev(request, opts) {
+  const now = opts.now ?? Date.now;
+  const fetchFn = opts.fetchFn ?? fetch;
+  const limit = opts.timeoutMs ?? JEV_TIMEOUT_MS;
+  const redact = (text) => text.split(opts.key).join("[redacted]");
+  const started = now();
+  const controller = new AbortController();
+  let timer;
+  const expired = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      const err = new Error(`Jev did not answer within ${limit} ms`);
+      controller.abort(err);
+      reject(err);
+    }, limit);
+  });
+  let requestId = null;
+  const exchange = (async () => {
+    const res = await fetchFn(JEV_URL, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${opts.key}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ model: "jev-latest", ...request }),
+      signal: controller.signal
+    });
+    requestId = res.headers.get("request-id") ?? res.headers.get("x-request-id");
+    return { res, text: await res.text() };
+  })();
+  exchange.catch(() => {
+  });
+  try {
+    const { res, text } = await Promise.race([exchange, expired]);
+    if (!res.ok) return { error: redact(`HTTP ${res.status}: ${text}`).slice(0, 300), requestId, ms: now() - started };
+    const body = JSON.parse(text);
+    const answers = {};
+    for (const [id, answer] of Object.entries(body.answers ?? {})) {
+      if (typeof answer?.noul === "number") answers[id] = answer.noul;
+    }
+    return { answers, model: typeof body.model === "string" ? body.model : null, requestId, ms: now() - started };
+  } catch (err) {
+    return { error: redact(String(err?.message ?? err)).slice(0, 300), requestId, ms: now() - started };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/key.ts
 import fs5 from "fs";
 import path6 from "path";
+var CHECK_REQUEST = {
+  state: { text: "hello" },
+  questions: { ok: { type: "noul", instructions: "Is `text` a greeting?", criteria: { true: "It is a greeting.", false: "It is not a greeting." } } }
+};
+var REJECTED = /^HTTP 40[13]\b/;
+async function checkJevKey(key, fetchFn) {
+  const result = await callJev(CHECK_REQUEST, { key, fetchFn });
+  if (!("error" in result)) return { status: "ok" };
+  return REJECTED.test(result.error) ? { status: "rejected", detail: result.error } : { status: "unchecked", detail: result.error };
+}
+function saveJevKey(home, key) {
+  const file = savedKeyPath(home);
+  fs5.mkdirSync(path6.dirname(file), { recursive: true });
+  fs5.writeFileSync(file, `TYPESAFE_API_KEY=${key}
+`, { mode: 384 });
+  fs5.chmodSync(file, 384);
+  return file;
+}
+async function promptForKey(prompt, check) {
+  for (; ; ) {
+    const key = (await prompt.ask("TypeSafe API key (Enter to skip): ")).trim();
+    if (!key) return null;
+    const result = await check(key);
+    if (result.status === "ok") return key;
+    if (result.status === "unchecked") {
+      prompt.say(`Saved without a check: could not check the key (${result.detail}).`);
+      return key;
+    }
+    prompt.say(`That key did not work (${result.detail}). Try again, or press Enter to skip.`);
+  }
+}
+
+// src/status.ts
+import fs6 from "fs";
+import path7 from "path";
 
 // src/display/line.ts
 var PHRASES = {
@@ -433,24 +598,6 @@ function parseState(raw) {
   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) {
@@ -461,19 +608,19 @@ function displaySetUp(settings, config) {
   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, "/")));
+  const hasDir = dirs.split(path7.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))) {
+    for (const name of fs6.readdirSync(stateDir(home))) {
       if (!name.endsWith(".json")) continue;
-      const file = path6.join(stateDir(home), name);
-      const mtime = fs5.statSync(file).mtimeMs;
+      const file = path7.join(stateDir(home), name);
+      const mtime = fs6.statSync(file).mtimeMs;
       if (!newest || mtime > newest.mtime) newest = { file, mtime };
     }
-    return newest ? parseState(JSON.parse(fs5.readFileSync(newest.file, "utf8"))) : null;
+    return newest ? parseState(JSON.parse(fs6.readFileSync(newest.file, "utf8"))) : null;
   } catch {
     return null;
   }
@@ -511,7 +658,7 @@ function statusLines(home, env = process.env) {
     lines.push(`${feature}: installed, ${state}`);
     for (const c of commands) {
       const script = SCRIPT_IN_COMMAND.exec(c.command)?.[1];
-      if (script && !fs5.existsSync(script)) {
+      if (script && !fs6.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}"`);
       }
     }
@@ -533,6 +680,7 @@ var USAGE = [
   "  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",
+  "  key                        ask for the TypeSafe API key, check it and save it",
   "",
   "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.',
@@ -570,7 +718,33 @@ function checkOptions(command, options) {
   if (options.display !== void 0 && !DISPLAYS2.includes(options.display)) return "--display takes mod, statusline or message";
   return null;
 }
-function runCli(argv, io) {
+async function askAndSaveKey(io, prompt) {
+  const key = await promptForKey(prompt, io.checkKey ?? ((candidate) => checkJevKey(candidate)));
+  if (!key) {
+    io.out('No key saved. Run "claude-jev-advisor key" to add one later.');
+    return;
+  }
+  const before = readConfig(io.home).keyFile;
+  const file = saveJevKey(io.home, key);
+  updateConfig(io.home, (c) => ({ ...c, keyFile: file }));
+  io.out(`Saved the key to ${file}`);
+  if (before && path8.resolve(before) !== path8.resolve(file)) io.out(`The config now uses this file instead of ${before}.`);
+  if ((io.env ?? process.env).TYPESAFE_API_KEY?.trim()) io.out("TYPESAFE_API_KEY is set in your environment; the hooks use it before the saved key.");
+}
+async function ensureKey(io, keyFileGiven) {
+  const keyFile = readConfig(io.home).keyFile;
+  if (readJevKey(io.env ?? process.env, keyFile)) return;
+  if (keyFileGiven) {
+    io.out(`No TYPESAFE_API_KEY line found in ${keyFile}; context cannot judge until it has one.`);
+    return;
+  }
+  if (!io.prompt) {
+    io.out('No TypeSafe API key yet: run "claude-jev-advisor key" in a terminal to add one (context needs it to judge).');
+    return;
+  }
+  await askAndSaveKey(io, io.prompt);
+}
+async function runCli(argv, io) {
   const parsed = parse(argv);
   const problem = typeof parsed === "string" ? parsed : checkOptions(parsed.command, parsed.options);
   if (typeof parsed === "string" || problem) {
@@ -589,7 +763,7 @@ function runCli(argv, io) {
           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"]),
+          keyFile: options["key-file"] === void 0 || path8.isAbsolute(options["key-file"]) ? options["key-file"] : path8.resolve(options["key-file"]),
           display: options.display
         });
         for (const f of r.installed) io.out(`installed ${f}`);
@@ -597,7 +771,12 @@ function runCli(argv, io) {
         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.");
+        if (r.installed.length) {
+          io.out(
+            r.display === "mod" ? "Hooks apply right away, also in open Claude Code sessions; the bottom-row display starts with the next new session." : "Hooks apply right away, also in open Claude Code sessions."
+          );
+        }
+        if (r.installed.includes("context")) await ensureKey(io, options["key-file"] !== void 0);
         return 0;
       }
       case "uninstall": {
@@ -605,6 +784,15 @@ function runCli(argv, io) {
         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}`);
+        if (r.removed.includes("context") && fs7.existsSync(savedKeyPath(io.home))) io.out(`kept your saved TypeSafe key at ${savedKeyPath(io.home)}`);
+        return 0;
+      }
+      case "key": {
+        if (!io.prompt) {
+          io.err("claude-jev-advisor key needs an interactive terminal (or set TYPESAFE_API_KEY, or use install --key-file).");
+          return 1;
+        }
+        await askAndSaveKey(io, io.prompt);
         return 0;
       }
       case "on":
@@ -632,11 +820,21 @@ function runCli(argv, io) {
 }
 
 // src/cli.ts
-process.exitCode = runCli(process.argv.slice(2), {
+runCli(process.argv.slice(2), {
   home: os.homedir(),
-  distDir: path8.dirname(fileURLToPath(import.meta.url)),
+  distDir: path9.dirname(fileURLToPath(import.meta.url)),
   platform: process.platform,
   now: () => /* @__PURE__ */ new Date(),
   out: (line) => console.log(line),
-  err: (line) => console.error(line)
-});
+  err: (line) => console.error(line),
+  env: process.env,
+  prompt: terminalPrompt()
+}).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
+    console.error(`claude-jev-advisor: ${err?.message ?? err}`);
+    process.exitCode = 1;
+  }
+);

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

@@ -1,14 +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": ""
-    }
-  }
-}
+{
+  "name": "jev-advisor",
+  "version": "0.1.2",
+  "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/package.json

@@ -1,48 +1,48 @@
-{
-  "name": "@delt/claude-jev-advisor",
-  "version": "0.1.0",
-  "description": "Unofficial Claude Code helpers using TypeSafe Jev: compact/clear advice and an rm guard",
-  "type": "module",
-  "bin": {
-    "claude-jev-advisor": "./dist/cli.js"
-  },
-  "files": [
-    "dist",
-    "mod",
-    "README.md"
-  ],
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "scripts": {
-    "build": "tsup",
-    "typecheck": "tsc --noEmit",
-    "test": "node --import tsx --import ./test/isolate-home.ts --test --test-timeout=30000 \"test/**/*.test.ts\"",
-    "prepack": "npm run build"
-  },
-  "keywords": [
-    "claude",
-    "claude-code",
-    "hooks",
-    "compact",
-    "context",
-    "typesafe",
-    "jev",
-    "rm"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/delt96/claude-jev-advisor.git"
-  },
-  "bugs": {
-    "url": "https://github.com/delt96/claude-jev-advisor/issues"
-  },
-  "homepage": "https://github.com/delt96/claude-jev-advisor#readme",
-  "devDependencies": {
-    "@types/node": "^22.0.0",
-    "tsup": "^8.0.0",
-    "tsx": "^4.23.15",
-    "typescript": "^5.5.0"
-  }
-}
+{
+  "name": "@delt/claude-jev-advisor",
+  "version": "0.1.2",
+  "description": "Unofficial Claude Code helpers using TypeSafe Jev: compact/clear advice and an rm guard",
+  "type": "module",
+  "bin": {
+    "claude-jev-advisor": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "mod",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --import ./test/isolate-home.ts --test --test-timeout=30000 \"test/**/*.test.ts\"",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "hooks",
+    "compact",
+    "context",
+    "typesafe",
+    "jev",
+    "rm"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/delt96/claude-jev-advisor.git"
+  },
+  "bugs": {
+    "url": "https://github.com/delt96/claude-jev-advisor/issues"
+  },
+  "homepage": "https://github.com/delt96/claude-jev-advisor#readme",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "tsx": "^4.23.15",
+    "typescript": "^5.5.0"
+  }
+}