nathangong 0.1.0

package/README.md

@@ -0,0 +1,64 @@
+# nathangong
+
+Pops a macOS notification with a photo of **Nathan Gong** every time Claude Code
+finishes responding to a prompt. Download it and it just works.
+
+## Install
+
+```bash
+npm install -g nathangong
+```
+
+That's it. The `postinstall` step wires a Claude Code [`Stop` hook](https://docs.claude.com/en/docs/claude-code/hooks)
+into `~/.claude/settings.json`. The next time Claude finishes a turn, Nathan says hi.
+
+### Photos vs. emoji
+
+The photo is rendered via the bundled [`node-notifier`](https://github.com/mikaelbr/node-notifier),
+whose `terminal-notifier` binary is **x86_64**. So:
+
+- **Intel Mac**, or **Apple Silicon with Rosetta** → you get the **photo**. 📸
+- **Apple Silicon without Rosetta** → you get an **emoji notification** (macOS
+  can't attach a custom image without a runnable helper binary).
+
+To get photos on Apple Silicon, install Rosetta once:
+
+```bash
+softwareupdate --install-rosetta --agree-to-license
+```
+
+## Commands
+
+```bash
+nathangong test        # fire a notification right now to check it works
+nathangong install     # (re)wire the Stop hook
+nathangong uninstall   # remove the Stop hook
+```
+
+## Uninstall
+
+```bash
+npm uninstall -g nathangong
+```
+
+The `preuninstall` step removes the hook from your settings. (You can also run
+`nathangong uninstall` first.)
+
+## How it works
+
+- The `Stop` hook runs `node .../scripts/notify.js` when Claude ends a turn.
+- `notify.js` picks a random photo from `assets/` and fires a notification via
+  `node-notifier` (`contentImage`), falling back to `osascript` (emoji only).
+- Editing `~/.claude/settings.json` is idempotent and backs the file up to
+  `settings.json.nathangong.bak` before any change.
+
+## Use as a library
+
+```js
+const { photos, randomPhoto } = require("nathangong");
+randomPhoto(); // → absolute path to a Nathan Gong photo
+```
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawn } = require("child_process");
+const { addHook, removeHook, notifyScriptPath } = require("../scripts/settings");
+
+process.stdout.on("error", () => {});
+
+const cmd = (process.argv[2] || "").toLowerCase();
+
+function install() {
+  const res = addHook();
+  console.log(
+    res.changed
+      ? "🔔 nathangong: Stop hook installed → " + res.path
+      : "🔔 nathangong: Stop hook already present → " + res.path
+  );
+}
+
+function uninstall() {
+  const res = removeHook();
+  console.log(
+    res.changed
+      ? "👋 nathangong: Stop hook removed."
+      : "nathangong: no Stop hook found (nothing to remove)."
+  );
+}
+
+function test() {
+  console.log("nathangong: firing a test notification…");
+  const child = spawn(process.execPath, [notifyScriptPath()], { stdio: "inherit" });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
+function help() {
+  console.log("nathangong — Nathan Gong greets you after every Claude Code turn.\n");
+  console.log("Usage:");
+  console.log("  nathangong install     wire the Claude Code Stop hook");
+  console.log("  nathangong uninstall   remove the hook");
+  console.log("  nathangong test        fire a test notification now");
+}
+
+switch (cmd) {
+  case "install":
+    install();
+    break;
+  case "uninstall":
+    uninstall();
+    break;
+  case "test":
+    test();
+    break;
+  default:
+    help();
+}

package/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+// A real, importable module — not just a hook. Exposes the bundled photos.
+
+const fs = require("fs");
+const path = require("path");
+
+/** Absolute paths to every bundled Nathan Gong photo. */
+function photos() {
+  const dir = path.join(__dirname, "assets");
+  return fs
+    .readdirSync(dir)
+    .filter((f) => /\.(png|jpe?g|gif)$/i.test(f))
+    .map((f) => path.join(dir, f));
+}
+
+/** A random Nathan Gong photo path. */
+function randomPhoto() {
+  const all = photos();
+  return all[Math.floor(Math.random() * all.length)];
+}
+
+module.exports = { photos, randomPhoto };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "nathangong",
+  "version": "0.1.0",
+  "description": "Pops a macOS notification with a photo of Nathan Gong after every Claude Code turn.",
+  "keywords": [
+    "nathan gong",
+    "claude",
+    "claude-code",
+    "hook",
+    "notification",
+    "macos",
+    "fun"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "bin": {
+    "nathangong": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "assets",
+    "index.js",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "preuninstall": "node scripts/preuninstall.js",
+    "test": "node bin/cli.js test"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "dependencies": {
+    "node-notifier": "^10.0.1"
+  }
+}

package/scripts/notify.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+"use strict";
+
+// The Claude Code `Stop` hook body: fires each time Claude finishes a turn.
+// Pops a macOS notification with a random photo of Nathan Gong.
+//
+// Uses node-notifier, which bundles its own copy of terminal-notifier and
+// supports `contentImage` — so the photo shows up with no extra system setup
+// (no Homebrew needed). Falls back to plain `osascript` (emoji only) if
+// node-notifier is unavailable or errors.
+//
+// Rules: always exit 0 (a failing hook nags every turn) and never hang.
+
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+
+process.stdout.on("error", () => {});
+process.stderr.on("error", () => {});
+
+const TITLE = "nathan gong 🔔";
+const LINES = [
+  "nathan gong has entered the chat 🧑‍💻",
+  "a wild nathan gong appears 👋",
+  "nathan gong approves this prompt ✅",
+  "thinking about nathan gong 🤔",
+  "nathan gong says: nice turn 🏀",
+];
+
+function pick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function pickImage() {
+  try {
+    const dir = path.join(__dirname, "..", "assets");
+    const files = fs
+      .readdirSync(dir)
+      .filter((f) => /\.(png|jpe?g|gif)$/i.test(f))
+      .map((f) => path.join(dir, f));
+    return files.length ? pick(files) : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function done() {
+  process.exit(0);
+}
+
+// Emoji-only fallback — macOS's built-in notification can't render an image.
+function osascriptFallback(line) {
+  const script =
+    "display notification " +
+    JSON.stringify(line) +
+    " with title " +
+    JSON.stringify(TITLE);
+  const child = spawn("osascript", ["-e", script], {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+}
+
+function main() {
+  if (process.platform !== "darwin") return done();
+
+  const line = pick(LINES);
+  const image = pickImage();
+
+  // Safety net: never let the hook hang the turn.
+  const safety = setTimeout(done, 5000);
+  safety.unref();
+
+  let notifier;
+  try {
+    notifier = require("node-notifier");
+  } catch (_) {
+    osascriptFallback(line);
+    return done();
+  }
+
+  try {
+    notifier.notify(
+      {
+        title: TITLE,
+        message: line,
+        contentImage: image || undefined, // right-side thumbnail (the photo)
+        appIcon: image || undefined, // left icon
+        sound: false,
+        wait: false,
+      },
+      (err) => {
+        if (err) osascriptFallback(line);
+        done();
+      }
+    );
+  } catch (_) {
+    osascriptFallback(line);
+    done();
+  }
+}
+
+main();

package/scripts/postinstall.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+"use strict";
+
+// Runs automatically on `npm install`. Wires the Claude Code `Stop` hook so
+// Nathan Gong greets you after every turn. Must NEVER exit non-zero — that
+// would fail the user's `npm install`.
+
+// Never let a closed output pipe (e.g. npm truncating our logs) crash install.
+process.stdout.on("error", () => {});
+
+function log(msg) {
+  try {
+    process.stdout.write(msg + "\n");
+  } catch (_) {}
+}
+
+try {
+  const { addHook } = require("./settings");
+  const res = addHook();
+  if (res.changed) {
+    log("🔔 nathangong: wired a Claude Code Stop hook → " + res.path);
+    log("   Nathan Gong will now greet you after every Claude turn.");
+    log("   Try it now:  nathangong test");
+  } else {
+    log("🔔 nathangong: Stop hook already present (nothing to do).");
+  }
+} catch (err) {
+  log("nathangong: couldn't wire the hook automatically (" + (err && err.message) + ").");
+  log("nathangong: run `nathangong install` to set it up manually.");
+}
+
+// Apple Silicon without Rosetta can't run the bundled x86_64 terminal-notifier,
+// so it falls back to an emoji notification. Let the user know how to get photos.
+try {
+  const os = require("os");
+  if (process.platform === "darwin" && os.arch() === "arm64") {
+    const { execFileSync } = require("child_process");
+    let rosetta = false;
+    try {
+      execFileSync("/usr/bin/pgrep", ["-q", "oahd"]);
+      rosetta = true;
+    } catch (_) {}
+    if (!rosetta) {
+      log("");
+      log("nathangong: you're on Apple Silicon without Rosetta — you'll get emoji");
+      log("nathangong: notifications. For actual PHOTOS of Nathan, install Rosetta once:");
+      log("   softwareupdate --install-rosetta --agree-to-license");
+    }
+  }
+} catch (_) {}

package/scripts/preuninstall.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+"use strict";
+
+// Runs on `npm uninstall`. Removes our Stop hook so a deleted notify.js can't
+// error on every turn. Best-effort — never throw.
+
+try {
+  const { removeHook } = require("./settings");
+  const res = removeHook();
+  if (res.changed) {
+    process.stdout.write("nathangong: removed the Claude Code Stop hook. 👋\n");
+  }
+} catch (_) {
+  /* best effort */
+}

package/scripts/settings.js

@@ -0,0 +1,121 @@
+"use strict";
+
+// Shared helpers for reading/writing the Claude Code user settings file and
+// adding/removing our `Stop` hook. The Stop hook fires each time Claude Code
+// finishes responding to a prompt — that's our "after every claude prompt".
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+function settingsPath() {
+  return path.join(os.homedir(), ".claude", "settings.json");
+}
+
+function notifyScriptPath() {
+  return path.join(__dirname, "notify.js");
+}
+
+function hookCommand() {
+  return `node "${notifyScriptPath()}"`;
+}
+
+// A hook is "ours" if its command shells out to nathangong's notify.js.
+function isOurHook(command) {
+  return (
+    typeof command === "string" &&
+    command.includes("nathangong") &&
+    command.includes("notify.js")
+  );
+}
+
+function readSettings(p) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(p, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (err) {
+    if (err && err.code === "ENOENT") return {};
+    // Malformed/unreadable: preserve it rather than clobber blindly.
+    try {
+      fs.copyFileSync(p, p + ".nathangong.corrupt.bak");
+    } catch (_) {}
+    return {};
+  }
+}
+
+function writeSettings(p, settings) {
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(settings, null, 2) + "\n", "utf8");
+}
+
+function hasOurHook(settings) {
+  const stop = settings && settings.hooks && settings.hooks.Stop;
+  return (
+    Array.isArray(stop) &&
+    stop.some(
+      (entry) =>
+        entry &&
+        Array.isArray(entry.hooks) &&
+        entry.hooks.some((h) => isOurHook(h && h.command))
+    )
+  );
+}
+
+function addHook() {
+  const p = settingsPath();
+  const settings = readSettings(p);
+
+  // Back up the existing file before we touch it.
+  try {
+    if (fs.existsSync(p)) fs.copyFileSync(p, p + ".nathangong.bak");
+  } catch (_) {}
+
+  if (hasOurHook(settings)) return { changed: false, path: p };
+
+  if (!settings.hooks || typeof settings.hooks !== "object") settings.hooks = {};
+  if (!Array.isArray(settings.hooks.Stop)) settings.hooks.Stop = [];
+
+  settings.hooks.Stop.push({
+    hooks: [{ type: "command", command: hookCommand() }],
+  });
+
+  writeSettings(p, settings);
+  return { changed: true, path: p };
+}
+
+function removeHook() {
+  const p = settingsPath();
+  if (!fs.existsSync(p)) return { changed: false, path: p };
+
+  const settings = readSettings(p);
+  const stop = settings && settings.hooks && settings.hooks.Stop;
+  if (!Array.isArray(stop)) return { changed: false, path: p };
+
+  let changed = false;
+  const filtered = stop
+    .map((entry) => {
+      if (!entry || !Array.isArray(entry.hooks)) return entry;
+      const kept = entry.hooks.filter((h) => !isOurHook(h && h.command));
+      if (kept.length !== entry.hooks.length) changed = true;
+      return Object.assign({}, entry, { hooks: kept });
+    })
+    .filter((entry) => !entry || !Array.isArray(entry.hooks) || entry.hooks.length > 0);
+
+  if (!changed) return { changed: false, path: p };
+
+  settings.hooks.Stop = filtered;
+  if (settings.hooks.Stop.length === 0) delete settings.hooks.Stop;
+  if (settings.hooks && Object.keys(settings.hooks).length === 0) delete settings.hooks;
+
+  writeSettings(p, settings);
+  return { changed: true, path: p };
+}
+
+module.exports = {
+  settingsPath,
+  notifyScriptPath,
+  hookCommand,
+  isOurHook,
+  addHook,
+  removeHook,
+};