agentinel 1.0.3 → 1.0.5

package/README.md

@@ -42,11 +42,17 @@ Every other tool in this space guards your terminal. **Agentinel guards your age
 
 ## 🚀 Installation
 
-Install it as a dev-dependency in your repository:
+For the best experience across all your projects and to use the short `asen` alias, install Agentinel globally:
 
+```sh
+npm install -g agentinel
+asen init
+```
+
+Alternatively, you can install it as a dev-dependency per-project:
 ```sh
 npm install --save-dev agentinel
-npx asen init
+npx agentinel init
 ```
 *(No account, no server, no complex configuration.)*
 
@@ -83,7 +89,9 @@ Agentinel provides an opt-in **PATH shim**. By default, running `npx asen init`
 npx asen init
 ```
 
-This puts a tiny, fail-open wrapper script earlier in your `PATH`. When you type `npm install`, the shim checks the package first. If it's safe, the real `npm` command runs instantly. 
+This puts a tiny, fail-open wrapper script earlier in your `PATH`. When you type `npm install <pkg>`, the shim checks the package first. If it's safe, the real `npm` command runs instantly. 
+
+As a bonus, if you just run a plain `npm install` with no arguments, the shim instantly checks your unstaged `package.json` for any newly added dependencies, ensuring that packages you pasted in are scanned before they resolve!
 
 **Terminal Example:**
 ```bash
@@ -151,22 +159,43 @@ Agentinel hard-blocks the install and returns an error payload to the agent. The
 
 ## 🧰 Command Reference
 
-Here are all the commands you can run via `npx asen <command>`:
+You can run Agentinel using `npx agentinel <command>`. 
+If you have installed `agentinel` globally (`npm install -g agentinel`) or locally in your project, you can use the shorter alias: `npx asen <command>` (or just `asen <command>` if global).
+
+Here are all the commands:
 
 ### `npx asen init [--no-shim]`
 Wires up agent hooks and git hooks in the current repo, and installs the global PATH shim for human terminal protection.
 ```bash
 $ npx asen init
-wrote .agentinel.json
-registered the Claude Code PreToolUse hook in .claude/settings.json
-installed the git pre-commit hook in .git/hooks
-wrote shims for npm, npx, pnpm, yarn, bun in /Users/user/.agentinel/bin
-added the shims to PATH in /Users/user/.zshrc
-Mode is warn, so a risky package typed at the terminal will be reported, not blocked.
-Open a new terminal, or run \`asen unshim\` to undo this.
 
-agentinel is set up. New npm packages will be checked before they land.
-Default mode is warn. Set "mode": "strict" in .agentinel.json to block instead.
+╭─ agentinel ──────────────────────────────╮
+│  agentinel setup complete                │
+│                                          │
+│  New npm packages will be checked before │
+│  they land.                              │
+│                                          │
+│  ✔ wrote .agentinel.json                 │
+│  ✔ registered the Claude Code PreToolUse │
+│  hook in .claude/settings.json           │
+│  ✔ installed the git pre-commit hook in  │
+│  .git/hooks                              │
+│  ✔ wrote shims for npm, npx, pnpm, yarn, │
+│  bun in /Users/user/.agentinel/bin       │
+│  ✔ added the shims to PATH in            │
+│  /Users/user/.zshrc                      │
+│  ✔ Open a new terminal, or run `asen     │
+│  unshim` to undo this.                   │
+│                                          │
+│  Default mode is strict. Set "mode":     │
+│  "warn" in .agentinel.json to only warn  │
+│  instead.                                │
+╰──────────────────────────────────────────╯
+
+Performance Tip:
+The hook runs on every command, and resolving through npx each time is slow.
+For faster hooks, add it to the repo and run init again:
+  npm install --save-dev agentinel && npx asen init
 ```
 
 When used with `--no-shim`, it wires up hooks but skips installing the global PATH shim.
@@ -177,11 +206,11 @@ registered the Claude Code PreToolUse hook in .claude/settings.json
 installed the git pre-commit hook in .git/hooks
 
 agentinel is set up. New npm packages will be checked before they land.
-Default mode is warn. Set "mode": "strict" in .agentinel.json to block instead.
+Default mode is strict. Set "mode": "warn" in .agentinel.json to only warn instead.
 ```
 
 ### `npx asen check [pkg...]`
-Scans the currently staged dependencies in your lockfile. Exits non-zero if flagged (great for CI/CD pipelines).
+Scans the unstaged (or newly added) dependencies in your working tree, including the lockfile. Exits non-zero if flagged. (The Git pre-commit hook uses a strictly staged version of this check).
 ```bash
 $ npx asen check
 checked 142 package(s), nothing suspicious

package/dist/asen.js

@@ -27,27 +27,68 @@ function readFlag(args, flag) {
 
 // src/checks/package-guard/staged-deps.ts
 import { execFileSync } from "child_process";
+import { readFileSync, lstatSync } from "fs";
+import { join, resolve, sep } from "path";
 var DEP_FIELDS = ["dependencies", "devDependencies", "optionalDependencies"];
 function newStagedDependencies(repoRoot) {
   const names = [];
-  for (const path of stagedManifestPaths(repoRoot)) {
+  for (const path of changedManifestPaths(repoRoot, [
+    "diff",
+    "--cached",
+    "--name-only",
+    "-z",
+    "--diff-filter=ACMR"
+  ]) ?? []) {
     const staged = gitJson(repoRoot, `:${path}`);
-    if (!staged) {
-      continue;
-    }
+    if (!staged) continue;
     const before = collectNames(gitJson(repoRoot, `HEAD:${path}`) ?? {});
     for (const name of collectNames(staged)) {
-      if (!before.has(name) && !names.includes(name)) {
-        names.push(name);
+      if (!before.has(name) && !names.includes(name)) names.push(name);
+    }
+  }
+  return names;
+}
+function newWorkingTreeDependencies(repoRoot) {
+  const names = [];
+  let paths = changedManifestPaths(repoRoot, [
+    "diff",
+    "HEAD",
+    "--name-only",
+    "-z",
+    "--diff-filter=ACMR"
+  ]);
+  if (paths === null) {
+    paths = changedManifestPaths(repoRoot, ["ls-files", "-z", "-c", "-o", "--exclude-standard"]) ?? [];
+  } else {
+    const untracked = changedManifestPaths(repoRoot, ["ls-files", "-z", "-o", "--exclude-standard"]) ?? [];
+    paths = Array.from(/* @__PURE__ */ new Set([...paths, ...untracked]));
+  }
+  for (const path of paths) {
+    let onDisk = null;
+    try {
+      const fullPath = resolve(join(repoRoot, path));
+      if (!fullPath.startsWith(resolve(repoRoot) + sep) && fullPath !== resolve(repoRoot)) {
+        continue;
       }
+      if (lstatSync(fullPath).isSymbolicLink()) {
+        continue;
+      }
+      onDisk = JSON.parse(readFileSync(fullPath, "utf8"));
+    } catch {
+      continue;
+    }
+    if (!onDisk) continue;
+    const before = collectNames(gitJson(repoRoot, `HEAD:${path}`) ?? {});
+    for (const name of collectNames(onDisk)) {
+      if (!before.has(name) && !names.includes(name)) names.push(name);
     }
   }
   return names;
 }
-function stagedManifestPaths(repoRoot) {
-  const output = git(repoRoot, ["diff", "--cached", "--name-only", "-z", "--diff-filter=ACMR"]);
+function changedManifestPaths(repoRoot, gitArgs) {
+  const output = git(repoRoot, gitArgs);
   if (output === null) {
-    return [];
+    return null;
   }
   return output.split("\0").filter((path) => path === "package.json" || path.endsWith("/package.json")).filter((path) => !isInsideDependencies(path));
 }
@@ -96,14 +137,14 @@ function git(cwd, args) {
 }
 
 // src/config/load.ts
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { join } from "path";
+import { readFileSync as readFileSync2, writeFileSync, existsSync } from "fs";
+import { join as join2 } from "path";
 
 // src/config/schema.ts
 var CONFIG_FILENAME = ".agentinel.json";
 function defaultConfig() {
   return {
-    mode: "warn",
+    mode: "strict",
     allow: [
       {
         name: "asen",
@@ -129,7 +170,7 @@ function parseConfig(raw, warn2 = () => {
     config.mode = source.mode;
   } else if (source.mode !== void 0) {
     warn2(
-      `unknown mode ${JSON.stringify(source.mode)} in ${CONFIG_FILENAME}, falling back to "warn". Valid modes are "warn" and "strict".`
+      `unknown mode ${JSON.stringify(source.mode)} in ${CONFIG_FILENAME}, falling back to "strict". Valid modes are "warn" and "strict".`
     );
   }
   if (Array.isArray(source.allow)) {
@@ -155,7 +196,7 @@ function isAllowlisted(config, name) {
 var ConfigError = class extends Error {
 };
 function configPath(repoRoot) {
-  return join(repoRoot, CONFIG_FILENAME);
+  return join2(repoRoot, CONFIG_FILENAME);
 }
 function loadConfig(repoRoot) {
   const path = configPath(repoRoot);
@@ -164,7 +205,7 @@ function loadConfig(repoRoot) {
   }
   let text;
   try {
-    text = readFileSync(path, "utf8");
+    text = readFileSync2(path, "utf8");
   } catch (error) {
     throw new ConfigError(`could not read ${CONFIG_FILENAME}: ${describe(error)}`);
   }
@@ -304,8 +345,8 @@ function describeFailure(error) {
 }
 
 // src/checks/package-guard/malware.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname, join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { dirname, join as join3 } from "path";
 import { fileURLToPath } from "url";
 import { gunzipSync } from "zlib";
 var cache = null;
@@ -331,7 +372,7 @@ function load() {
     return {};
   }
   try {
-    const raw = gunzipSync(readFileSync2(path)).toString("utf8");
+    const raw = gunzipSync(readFileSync3(path)).toString("utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed === "object" && parsed !== null ? parsed : {};
   } catch {
@@ -341,9 +382,9 @@ function load() {
 function listPath() {
   const here = dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    join2(here, "..", "data", "malware-names.json.gz"),
-    join2(here, "..", "..", "data", "malware-names.json.gz"),
-    join2(here, "..", "..", "..", "data", "malware-names.json.gz")
+    join3(here, "..", "data", "malware-names.json.gz"),
+    join3(here, "..", "..", "data", "malware-names.json.gz"),
+    join3(here, "..", "..", "..", "data", "malware-names.json.gz")
   ];
   return candidates.find((path) => existsSync2(path)) ?? null;
 }
@@ -735,15 +776,18 @@ function scanForKnownMalware(tree, config) {
 
 // src/checks/package-guard/lockfile.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { join as join4 } from "path";
 function packagesInLockfile(repoRoot) {
-  const path = join3(repoRoot, "package-lock.json");
+  const path = join4(repoRoot, "package-lock.json");
   if (!existsSync3(path)) {
     return [];
   }
   return packagesInLockText(readFileOrNull(path));
 }
+function workingTreeLockfilePackages(repoRoot) {
+  return packagesInLockfile(repoRoot);
+}
 function stagedLockfilePackages(repoRoot) {
   let text = null;
   try {
@@ -778,7 +822,7 @@ function packagesInLockText(text) {
 }
 function readFileOrNull(path) {
   try {
-    return readFileSync3(path, "utf8");
+    return readFileSync4(path, "utf8");
   } catch {
     return null;
   }
@@ -818,7 +862,10 @@ function collectFromDependencies(lock, found) {
 var RESET = "\x1B[0m";
 var YELLOW = "\x1B[33m";
 var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var CYAN = "\x1B[36m";
 var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
 var WIDTH = 46;
 var TITLE = "agentinel";
 function supportsColor(stream = process.stdout) {
@@ -908,6 +955,39 @@ function draw(b, paint) {
   return b.action ? `${box}
   ${paint(DIM, b.action)}` : box;
 }
+function drawSuccessBox(heading, body, stream = process.stdout) {
+  const inner = WIDTH - 4;
+  const text = inner - 1;
+  const hasColor = supportsColor(stream);
+  const color = hasColor ? GREEN : "";
+  const paint = (code, str) => hasColor ? `${code}${str}${RESET}` : str;
+  const titlePart = hasColor ? `${BOLD}${TITLE}${RESET}${color}` : TITLE;
+  const top = paint(color, `\u256D\u2500 ${titlePart} ${"\u2500".repeat(WIDTH - TITLE.length - 5)}\u256E`);
+  const bottom = paint(color, `\u2570${"\u2500".repeat(WIDTH - 2)}\u256F`);
+  const rows = [];
+  const push = (line, styled) => {
+    const edge = paint(color, "\u2502");
+    const plainLine = (styled ?? line).replace(/\x1b\[[0-9;]*m/g, "");
+    const pad = " ".repeat(Math.max(0, inner - plainLine.length));
+    rows.push(`${edge}  ${styled ?? line}${pad}${edge}`);
+  };
+  push(heading, paint(BOLD, heading));
+  push("");
+  for (const line of body) {
+    if (line === "") {
+      push("");
+      continue;
+    }
+    if (line.includes("\x1B")) {
+      push(line, line);
+    } else {
+      for (const wrapped of wrap(line, text)) {
+        push(wrapped);
+      }
+    }
+  }
+  return [top, ...rows, bottom].join("\n");
+}
 function wrap(line, width) {
   const lines = [];
   let current = "";
@@ -981,8 +1061,8 @@ async function runCheck(names) {
     named = names;
     tree = [];
   } else {
-    named = newStagedDependencies(repoRoot);
-    tree = stagedLockfilePackages(repoRoot).filter((entry) => !named.includes(entry.name));
+    named = newWorkingTreeDependencies(repoRoot);
+    tree = workingTreeLockfilePackages(repoRoot).filter((entry) => !named.includes(entry.name));
   }
   if (named.length === 0 && tree.length === 0) {
     console.log("no new packages to check");
@@ -1020,9 +1100,9 @@ async function runCheck(names) {
 
 // src/commands/init.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { chmodSync as chmodSync2, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { isAbsolute, join as join5 } from "path";
+import { isAbsolute, join as join6 } from "path";
 
 // src/platform.ts
 function isWindows() {
@@ -1033,9 +1113,9 @@ function npmCommand() {
 }
 
 // src/commands/shim.ts
-import { chmodSync, existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { chmodSync, existsSync as existsSync4, mkdirSync, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync2 } from "fs";
 import { homedir } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 var CLIENTS = ["npm", "npx", "pnpm", "yarn", "bun"];
 var BLOCK_EXIT_CODE = 2;
 var RC_MARKER = "# agentinel";
@@ -1043,7 +1123,7 @@ function currentTarget() {
   return { home: homedir(), shell: process.env.SHELL ?? "", platform: process.platform };
 }
 function shimDirectory(home) {
-  return join4(home, ".agentinel", "bin");
+  return join5(home, ".agentinel", "bin");
 }
 function onWindows(target) {
   return target.platform === "win32";
@@ -1053,33 +1133,29 @@ function shimFileName(client, target) {
 }
 function startupFilePath(target) {
   if (onWindows(target)) {
-    return join4(target.home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
+    return join5(target.home, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1");
   }
   if (target.shell.includes("zsh")) {
-    return join4(target.home, ".zshrc");
+    return join5(target.home, ".zshrc");
   }
   if (target.shell.includes("bash")) {
-    return join4(target.home, ".bashrc");
+    return join5(target.home, ".bashrc");
   }
-  return join4(target.home, ".profile");
+  return join5(target.home, ".profile");
 }
-function installShim(repoRoot, target = currentTarget()) {
+function installShim(repoRoot, target = currentTarget(), messages = []) {
   const dir = shimDirectory(target.home);
   mkdirSync(dir, { recursive: true });
   for (const client of CLIENTS) {
-    const path = join4(dir, shimFileName(client, target));
+    const path = join5(dir, shimFileName(client, target));
     writeFileSync2(path, shimScript(client, target), "utf8");
     if (!onWindows(target)) {
       chmodSync(path, 493);
     }
   }
-  console.log(`wrote shims for ${CLIENTS.join(", ")} in ${dir}`);
-  addPathLine(target);
-  const mode = loadConfig(repoRoot).mode;
-  console.log(
-    mode === "strict" ? "Mode is strict, so a risky package typed at the terminal will be blocked." : "Mode is warn, so a risky package typed at the terminal will be reported, not blocked."
-  );
-  console.log("Open a new terminal, or run `asen unshim` to undo this.");
+  messages.push(`wrote shims for ${CLIENTS.join(", ")} in ${dir}`);
+  addPathLine(target, messages);
+  messages.push("Open a new terminal, or run `asen unshim` to undo this.");
   return 0;
 }
 function removeShim(target = currentTarget()) {
@@ -1097,24 +1173,24 @@ function pathLine(target) {
   return `export PATH="$HOME/.agentinel/bin:$PATH" ${RC_MARKER}
 `;
 }
-function addPathLine(target) {
+function addPathLine(target, messages) {
   const path = startupFilePath(target);
-  const existing = existsSync4(path) ? readFileSync4(path, "utf8") : "";
+  const existing = existsSync4(path) ? readFileSync5(path, "utf8") : "";
   if (existing.includes(RC_MARKER)) {
-    console.log(`${path} already puts the shims on PATH, left alone`);
+    messages.push(`${path} already puts the shims on PATH, left alone`);
     return;
   }
-  mkdirSync(join4(path, ".."), { recursive: true });
+  mkdirSync(join5(path, ".."), { recursive: true });
   const separator = existing === "" || existing.endsWith("\n") ? "" : "\n";
   writeFileSync2(path, `${existing}${separator}${pathLine(target)}`, "utf8");
-  console.log(`added the shims to PATH in ${path}`);
+  messages.push(`added the shims to PATH in ${path}`);
 }
 function removePathLine(target) {
   const path = startupFilePath(target);
   if (!existsSync4(path)) {
     return;
   }
-  const lines = readFileSync4(path, "utf8").split("\n");
+  const lines = readFileSync5(path, "utf8").split("\n");
   const kept = lines.filter((line) => !line.includes(RC_MARKER));
   if (kept.length === lines.length) {
     return;
@@ -1224,12 +1300,15 @@ async function runCheckCommand(command) {
   if (!command) {
     return 0;
   }
-  const { installs, executes } = parseCommand(command);
+  const { installs, executes, lockfile } = parseCommand(command);
+  const repoRoot = repoRootOrCwd();
   const names = [.../* @__PURE__ */ new Set([...installs, ...executes])];
   if (names.length === 0) {
-    return 0;
+    if (!lockfile) return 0;
+    const workingTree = newWorkingTreeDependencies(repoRoot);
+    if (workingTree.length === 0) return 0;
+    names.push(...workingTree);
   }
-  const repoRoot = repoRootOrCwd();
   const config = loadConfig(repoRoot);
   const verdicts = await checkPackages(names, config);
   for (const verdict of verdicts) {
@@ -1253,24 +1332,35 @@ var HOOK_MARKER = "agentinel";
 var HOOK_SUBCOMMAND = "hook claude-code";
 function runInit(options = {}) {
   const repoRoot = repoRootOrCwd();
-  writeConfig(repoRoot);
-  wireClaudeCodeHook(repoRoot, claudeCodeCommand(repoRoot));
-  wireOtherAgents(repoRoot, agentHookCommand(repoRoot));
-  wirePreCommitHook(repoRoot, gitHookCommand(repoRoot));
+  const messages = [];
+  writeConfig(repoRoot, messages);
+  wireClaudeCodeHook(repoRoot, claudeCodeCommand(repoRoot), messages);
+  wireOtherAgents(repoRoot, agentHookCommand(repoRoot), messages);
+  wirePreCommitHook(repoRoot, gitHookCommand(repoRoot), messages);
   if (options.shim) {
-    installShim(repoRoot, options.shimTarget);
-  }
-  console.log("\nagentinel is set up. New npm packages will be checked before they land.");
-  console.log('Default mode is warn. Set "mode": "strict" in .agentinel.json to block instead.');
+    installShim(repoRoot, options.shimTarget, messages);
+  }
+  const successBox = drawSuccessBox("agentinel setup complete", [
+    "New npm packages will be checked before they land.",
+    "",
+    ...messages.map((m) => `\u2714 ${m}`),
+    "",
+    `Default mode is ${GREEN}strict${RESET}.`,
+    'Set "mode": "warn" in .agentinel.json to only warn instead.'
+  ]);
+  console.log(`
+${successBox}`);
   if (!hasLocalInstall(repoRoot)) {
-    console.log("\nThe hook runs on every command, and going through npx each time is slow.");
-    console.log("For faster hooks, add it to the repo and run init again:");
-    console.log("  npm install --save-dev agentinel && npx asen init");
+    console.log(`
+${CYAN}Performance Tip:${RESET}`);
+    console.log(`The hook runs on every command, and resolving through npx each time is slow.`);
+    console.log(`For faster hooks, add it to the repo and run init again:`);
+    console.log(`  ${DIM}npm install --save-dev agentinel && npx asen init${RESET}`);
   }
   return 0;
 }
 function hasLocalInstall(repoRoot) {
-  return existsSync5(join5(repoRoot, "node_modules", ".bin", "asen"));
+  return existsSync5(join6(repoRoot, "node_modules", ".bin", "asen"));
 }
 function claudeCodeCommand(repoRoot) {
   if (isWindows()) {
@@ -1281,34 +1371,34 @@ function claudeCodeCommand(repoRoot) {
 function gitHookCommand(repoRoot) {
   return hasLocalInstall(repoRoot) ? "./node_modules/.bin/asen" : "npx agentinel";
 }
-function writeConfig(repoRoot) {
+function writeConfig(repoRoot, messages) {
   const path = configPath(repoRoot);
   if (existsSync5(path)) {
-    console.log(".agentinel.json already exists, left alone");
+    messages.push(".agentinel.json already exists, left alone");
     return;
   }
   saveConfig(repoRoot, defaultConfig());
-  console.log("wrote .agentinel.json");
+  messages.push("wrote .agentinel.json");
 }
-function wireClaudeCodeHook(repoRoot, command) {
-  const dir = join5(repoRoot, ".claude");
-  const path = join5(dir, "settings.json");
+function wireClaudeCodeHook(repoRoot, command, messages) {
+  const dir = join6(repoRoot, ".claude");
+  const path = join6(dir, "settings.json");
   let settings = {};
   if (existsSync5(path)) {
     try {
-      const parsed = JSON.parse(readFileSync5(path, "utf8"));
+      const parsed = JSON.parse(readFileSync6(path, "utf8"));
       if (typeof parsed === "object" && parsed !== null) {
         settings = parsed;
       }
     } catch {
-      console.log(".claude/settings.json is not valid JSON, skipping the Claude Code hook");
+      messages.push(".claude/settings.json is not valid JSON, skipping the Claude Code hook");
       return;
     }
   }
   const hooks = asRecord2(settings.hooks) ?? {};
   const preToolUse = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
   if (alreadyRegistered(preToolUse)) {
-    console.log("Claude Code hook already registered, left alone");
+    messages.push("Claude Code hook already registered, left alone");
     return;
   }
   preToolUse.push({
@@ -1319,7 +1409,7 @@ function wireClaudeCodeHook(repoRoot, command) {
   settings.hooks = hooks;
   mkdirSync2(dir, { recursive: true });
   writeFileSync3(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
-  console.log("registered the Claude Code PreToolUse hook in .claude/settings.json");
+  messages.push("registered the Claude Code PreToolUse hook in .claude/settings.json");
 }
 function agentHookCommand(repoRoot) {
   if (isWindows()) {
@@ -1327,31 +1417,31 @@ function agentHookCommand(repoRoot) {
   }
   return hasLocalInstall(repoRoot) ? '"$(git rev-parse --show-toplevel)"/node_modules/.bin/asen' : "npx agentinel";
 }
-function wireOtherAgents(repoRoot, command) {
+function wireOtherAgents(repoRoot, command, messages) {
   if (uses(repoRoot, ".codex")) {
-    wireCodexHook(repoRoot, command);
+    wireCodexHook(repoRoot, command, messages);
   }
-  if (uses(repoRoot, ".copilot") || existsSync5(join5(repoRoot, ".github", "hooks"))) {
-    wireCopilotHook(repoRoot, command);
+  if (uses(repoRoot, ".copilot") || existsSync5(join6(repoRoot, ".github", "hooks"))) {
+    wireCopilotHook(repoRoot, command, messages);
   }
   if (uses(repoRoot, ".gemini")) {
-    wireGeminiHook(repoRoot, command);
+    wireGeminiHook(repoRoot, command, messages);
   }
 }
 function uses(repoRoot, dir) {
-  return existsSync5(join5(repoRoot, dir)) || existsSync5(join5(homedir2(), dir));
+  return existsSync5(join6(repoRoot, dir)) || existsSync5(join6(homedir2(), dir));
 }
-function wireCodexHook(repoRoot, command) {
-  const path = join5(repoRoot, ".codex", "hooks.json");
+function wireCodexHook(repoRoot, command, messages) {
+  const path = join6(repoRoot, ".codex", "hooks.json");
   const file = readJson(path);
   if (file === null) {
-    console.log(".codex/hooks.json is not valid JSON, skipping the Codex hook");
+    messages.push(".codex/hooks.json is not valid JSON, skipping the Codex hook");
     return;
   }
   const hooks = asRecord2(file.hooks) ?? {};
   const preToolUse = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
   if (registers(preToolUse, "codex")) {
-    console.log("Codex hook already registered, left alone");
+    messages.push("Codex hook already registered, left alone");
     return;
   }
   preToolUse.push({
@@ -1361,19 +1451,19 @@ function wireCodexHook(repoRoot, command) {
   hooks.PreToolUse = preToolUse;
   file.hooks = hooks;
   writeJson(path, file);
-  console.log("registered the Codex PreToolUse hook in .codex/hooks.json");
+  messages.push("registered the Codex PreToolUse hook in .codex/hooks.json");
 }
-function wireCopilotHook(repoRoot, command) {
-  const path = join5(repoRoot, ".github", "hooks", "agentinel.json");
+function wireCopilotHook(repoRoot, command, messages) {
+  const path = join6(repoRoot, ".github", "hooks", "agentinel.json");
   const file = readJson(path);
   if (file === null) {
-    console.log(".github/hooks/agentinel.json is not valid JSON, skipping the Copilot hook");
+    messages.push(".github/hooks/agentinel.json is not valid JSON, skipping the Copilot hook");
     return;
   }
   const hooks = asRecord2(file.hooks) ?? {};
   const preToolUse = Array.isArray(hooks.preToolUse) ? hooks.preToolUse : [];
   if (registers(preToolUse, "copilot")) {
-    console.log("Copilot hook already registered, left alone");
+    messages.push("Copilot hook already registered, left alone");
     return;
   }
   preToolUse.push({ type: "command", matcher: "bash", bash: `${command} hook copilot` });
@@ -1381,19 +1471,19 @@ function wireCopilotHook(repoRoot, command) {
   file.version = 1;
   file.hooks = hooks;
   writeJson(path, file);
-  console.log("registered the Copilot preToolUse hook in .github/hooks/agentinel.json");
+  messages.push("registered the Copilot preToolUse hook in .github/hooks/agentinel.json");
 }
-function wireGeminiHook(repoRoot, command) {
-  const path = join5(repoRoot, ".gemini", "settings.json");
+function wireGeminiHook(repoRoot, command, messages) {
+  const path = join6(repoRoot, ".gemini", "settings.json");
   const file = readJson(path);
   if (file === null) {
-    console.log(".gemini/settings.json is not valid JSON, skipping the Gemini hook");
+    messages.push(".gemini/settings.json is not valid JSON, skipping the Gemini hook");
     return;
   }
   const hooks = asRecord2(file.hooks) ?? {};
   const beforeTool = Array.isArray(hooks.BeforeTool) ? hooks.BeforeTool : [];
   if (registers(beforeTool, "gemini")) {
-    console.log("Gemini hook already registered, left alone");
+    messages.push("Gemini hook already registered, left alone");
     return;
   }
   beforeTool.push({
@@ -1403,20 +1493,20 @@ function wireGeminiHook(repoRoot, command) {
   hooks.BeforeTool = beforeTool;
   file.hooks = hooks;
   writeJson(path, file);
-  console.log("registered the Gemini BeforeTool hook in .gemini/settings.json");
+  messages.push("registered the Gemini BeforeTool hook in .gemini/settings.json");
 }
 function readJson(path) {
   if (!existsSync5(path)) {
     return {};
   }
   try {
-    return asRecord2(JSON.parse(readFileSync5(path, "utf8"))) ?? {};
+    return asRecord2(JSON.parse(readFileSync6(path, "utf8"))) ?? {};
   } catch {
     return null;
   }
 }
 function writeJson(path, value) {
-  mkdirSync2(join5(path, ".."), { recursive: true });
+  mkdirSync2(join6(path, ".."), { recursive: true });
   writeFileSync3(path, JSON.stringify(value, null, 2) + "\n", "utf8");
 }
 function registers(entries, kind) {
@@ -1436,40 +1526,40 @@ function git2(repoRoot, args) {
 function hooksDirectory(repoRoot) {
   const configured = git2(repoRoot, ["config", "--get", "core.hooksPath"]);
   if (configured) {
-    return isAbsolute(configured) ? configured : join5(repoRoot, configured);
+    return isAbsolute(configured) ? configured : join6(repoRoot, configured);
   }
   const path = git2(repoRoot, ["rev-parse", "--git-path", "hooks"]);
   if (path) {
-    return isAbsolute(path) ? path : join5(repoRoot, path);
+    return isAbsolute(path) ? path : join6(repoRoot, path);
   }
-  return join5(repoRoot, ".git", "hooks");
+  return join6(repoRoot, ".git", "hooks");
 }
-function wirePreCommitHook(repoRoot, command) {
-  if (!existsSync5(join5(repoRoot, ".git"))) {
-    console.log("not a git repo, skipping the pre-commit hook");
+function wirePreCommitHook(repoRoot, command, messages) {
+  if (!existsSync5(join6(repoRoot, ".git"))) {
+    messages.push("not a git repo, skipping the pre-commit hook");
     return;
   }
   const dir = hooksDirectory(repoRoot);
-  const path = join5(dir, "pre-commit");
+  const path = join6(dir, "pre-commit");
   const script = `#!/bin/sh
 # ${HOOK_MARKER}: check newly added npm packages before they get committed
 ${command} hook pre-commit
 `;
   if (existsSync5(path)) {
-    const existing = readFileSync5(path, "utf8");
+    const existing = readFileSync6(path, "utf8");
     if (existing.includes(HOOK_MARKER)) {
-      console.log("pre-commit hook already installed, left alone");
+      messages.push("pre-commit hook already installed, left alone");
       return;
     }
-    console.log("a pre-commit hook already exists, not overwriting it");
-    console.log(`add this line to ${path}:
+    messages.push("a pre-commit hook already exists, not overwriting it");
+    messages.push(`add this line to ${path}:
   ${command} hook pre-commit`);
     return;
   }
   mkdirSync2(dir, { recursive: true });
   writeFileSync3(path, script, "utf8");
   chmodSync2(path, 493);
-  console.log(`installed the git pre-commit hook in ${dir}`);
+  messages.push(`installed the git pre-commit hook in ${dir}`);
 }
 function alreadyRegistered(preToolUse) {
   return JSON.stringify(preToolUse).includes(`${HOOK_SUBCOMMAND}`);
@@ -1497,8 +1587,8 @@ function runMode(targetMode) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync7, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7 } from "path";
 var HOOK_MARKER2 = "agentinel";
 var HOOK_SUBCOMMAND2 = "hook claude-code";
 function runUninstall() {
@@ -1513,7 +1603,7 @@ function runUninstall() {
   return 0;
 }
 function unwireClaudeCodeHook(repoRoot) {
-  const path = join6(repoRoot, ".claude", "settings.json");
+  const path = join7(repoRoot, ".claude", "settings.json");
   if (!existsSync6(path)) return;
   const file = readJson2(path);
   if (file === null) return;
@@ -1531,7 +1621,7 @@ function unwireClaudeCodeHook(repoRoot) {
   console.log("removed Claude Code hook");
 }
 function unwireCodexHook(repoRoot) {
-  const path = join6(repoRoot, ".codex", "hooks.json");
+  const path = join7(repoRoot, ".codex", "hooks.json");
   if (!existsSync6(path)) return;
   const file = readJson2(path);
   if (file === null) return;
@@ -1543,7 +1633,7 @@ function unwireCodexHook(repoRoot) {
   console.log("removed Codex hook");
 }
 function unwireCopilotHook(repoRoot) {
-  const path = join6(repoRoot, ".github", "hooks", "agentinel.json");
+  const path = join7(repoRoot, ".github", "hooks", "agentinel.json");
   if (!existsSync6(path)) return;
   const file = readJson2(path);
   if (file === null) return;
@@ -1555,7 +1645,7 @@ function unwireCopilotHook(repoRoot) {
   console.log("removed Copilot hook");
 }
 function unwireGeminiHook(repoRoot) {
-  const path = join6(repoRoot, ".gemini", "settings.json");
+  const path = join7(repoRoot, ".gemini", "settings.json");
   if (!existsSync6(path)) return;
   const file = readJson2(path);
   if (file === null) return;
@@ -1567,17 +1657,17 @@ function unwireGeminiHook(repoRoot) {
   console.log("removed Gemini hook");
 }
 function unwirePreCommitHook(repoRoot) {
-  if (!existsSync6(join6(repoRoot, ".git"))) return;
-  const path = join6(hooksDirectory(repoRoot), "pre-commit");
+  if (!existsSync6(join7(repoRoot, ".git"))) return;
+  const path = join7(hooksDirectory(repoRoot), "pre-commit");
   if (!existsSync6(path)) return;
-  const existing = readFileSync6(path, "utf8");
+  const existing = readFileSync7(path, "utf8");
   if (!existing.includes(HOOK_MARKER2)) return;
   rmSync2(path);
   console.log("removed git pre-commit hook");
 }
 function readJson2(path) {
   try {
-    return asRecord3(JSON.parse(readFileSync6(path, "utf8"))) ?? {};
+    return asRecord3(JSON.parse(readFileSync7(path, "utf8"))) ?? {};
   } catch {
     return null;
   }
@@ -1591,7 +1681,7 @@ function asRecord3(value) {
 
 // src/hooks/claude-code.ts
 import { existsSync as existsSync7 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/checks/package-guard/resolve.ts
 import { execFileSync as execFileSync4 } from "child_process";
@@ -1675,7 +1765,7 @@ function candidatesFor(command, repoRoot) {
 }
 function isLocalTool(repoRoot, name) {
   const binary = name.includes("/") ? name.split("/").pop() : name;
-  return existsSync7(join7(repoRoot, "node_modules", ".bin", binary));
+  return existsSync7(join8(repoRoot, "node_modules", ".bin", binary));
 }
 function warn(verdicts) {
   const summary = plainSummary(verdicts);
@@ -1889,14 +1979,14 @@ async function runPreCommitHook() {
 }
 
 // bin/asen.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { dirname as dirname2, join as join8 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { dirname as dirname2, join as join9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getVersion() {
   try {
     const file = fileURLToPath2(import.meta.url);
-    const pkgPath = join8(dirname2(file), "..", "package.json");
-    const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
+    const pkgPath = join9(dirname2(file), "..", "package.json");
+    const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "unknown";
   } catch {
     return "unknown";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentinel",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Catches AI hallucinated npm packages before an agent installs them",
   "license": "MIT",
   "author": "Aman Janwani",
@@ -14,7 +14,8 @@
   },
   "homepage": "https://github.com/aman-janwani/agentinel#readme",
   "bin": {
-    "asen": "./dist/asen.js"
+    "asen": "./dist/asen.js",
+    "agentinel": "./dist/asen.js"
   },
   "files": [
     "dist",