honeytree 1.0.1 → 1.0.2

package/README.md

@@ -1,44 +1,49 @@
 # Honeytree
 
+[![npm version](https://img.shields.io/npm/v/honeytree.svg)](https://www.npmjs.com/package/honeytree)
+[![license](https://img.shields.io/npm/l/honeytree.svg)](https://github.com/Varun2009178/honeytree/blob/main/LICENSE)
+
 Grow a pixel-art forest in your terminal every time you use Claude Code.
 
 Each prompt plants a new tree. Each tree grows over time. Your forest evolves from a quiet clearing into an ancient woodland — and it never resets.
 
-## Install
+---
+
+## Quick Start
 
 ```bash
 npm install -g honeytree
+honeytree init
+honeytree
 ```
 
-## Setup
+That's it. Three commands:
 
-```bash
-honeytree init
-```
+1. **Install** the CLI globally
+2. **Init** creates your forest file and registers a Claude Code hook
+3. **Run the viewer** in a separate terminal to watch your forest grow
 
-This creates `~/.honeydew/forest.json` and adds a `Stop` hook to your Claude Code settings so a tree is planted after every response.
+After setup, trees are planted automatically after every Claude Code response. No manual steps needed.
 
-## Watch your forest
+---
 
-```bash
-honeytree
-```
+## How It Works
 
-Open this in a separate terminal. It watches your forest file and animates new trees as they appear. Press `Ctrl+C` to exit.
+When you run `honeytree init`, it does two things:
 
-## How it works
+- Creates `~/.honeydew/forest.json` to store your forest state
+- Adds a `Stop` hook to `~/.claude/settings.json` that runs after every Claude Code response
 
-1. **`honeytree init`** — Creates the forest state file and registers a Claude Code hook
-2. **`honeytree`** — Opens the viewer that renders your forest in real time
+From then on, every time Claude Code responds to a prompt, a new tree is planted in your forest automatically. Open the viewer in a second terminal to watch them grow in real time.
 
-After init, a tree is automatically planted after every Claude Code response via the hook. Each tree is a random species (oak, pine, birch, willow, or cherry) and growth stage. Existing young trees grow a little each time too.
+---
 
 ## Biomes
 
-Your forest evolves as it grows:
+Your forest evolves visually as it grows — the sky, ground, and atmosphere all change:
 
 | Trees | Biome | What changes |
-|-------|-------|-------------|
+|------:|-------|-------------|
 | 0–9 | Clearing | Sparse stars, light ground |
 | 10–24 | Grove | More stars, richer ground |
 | 25–49 | Woodland | Dense canopy, varied starlight |
@@ -47,20 +52,42 @@ Your forest evolves as it grows:
 
 Trees are never deleted. The forest only grows.
 
-## Tree types
+---
 
-- **Oak** — Wide, rounded canopy
-- **Pine** — Tall, triangular shape
-- **Birch** — Light trunk, bright leaves
-- **Willow** — Drooping canopy
-- **Cherry** — Pink blossoms
+## Tree Species
 
-Each type has 4 growth stages: seed, sapling, young, and full.
+Five species are randomly assigned when a tree is planted:
+
+| Species | Look |
+|---------|------|
+| Oak | Wide, rounded canopy |
+| Pine | Tall, triangular shape |
+| Birch | Light trunk, bright leaves |
+| Willow | Drooping canopy |
+| Cherry | Pink blossoms |
+
+Each species has 4 growth stages (seed, sapling, young, full). Existing trees grow a little with each new prompt.
+
+---
+
+## Viewer
+
+The viewer adapts to your terminal width — expand your terminal and new trees will spread across the full width.
+
+Press `Ctrl+C` to exit. The viewer shows a summary of your forest when you close it.
+
+---
 
 ## Requirements
 
 - Node.js 18+
-- Claude Code (for the automatic hook)
+- [Claude Code](https://claude.com/claude-code) (for the automatic hook)
+
+## Links
+
+- **npm**: [npmjs.com/package/honeytree](https://www.npmjs.com/package/honeytree)
+- **GitHub**: [github.com/Varun2009178/honeytree](https://github.com/Varun2009178/honeytree)
+- **Issues**: [github.com/Varun2009178/honeytree/issues](https://github.com/Varun2009178/honeytree/issues)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honeytree",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Grow a forest in your terminal every time you use Claude Code",
   "type": "module",
   "bin": {

package/src/viewer.js

@@ -64,10 +64,12 @@ export async function viewer() {
   }
 
   // Save terminal width so plant knows how wide to spread trees
+  let ignoreNextChange = false;
   function syncWidth() {
     const cols = process.stdout.columns || 80;
     if (forest.viewerWidth !== cols) {
       forest.viewerWidth = cols;
+      ignoreNextChange = true;
       writeForest(forest);
     }
   }
@@ -78,6 +80,8 @@ export async function viewer() {
   renderForest(forest);
 
   let lastMaxId = forest.trees.reduce((max, tree) => Math.max(max, tree.id), 0);
+  let lastTotalPrompts = forest.totalPrompts;
+  let animating = false;
 
   const cleanup = () => {
     showCursor();
@@ -96,21 +100,70 @@ export async function viewer() {
     renderForest(forest);
   });
 
-  let debounceTimer;
-  fs.watch(forestFile, () => {
-    clearTimeout(debounceTimer);
-    debounceTimer = setTimeout(async () => {
-      const updated = readForest();
-      if (!updated) return;
-
-      const nextMaxId = updated.trees.reduce((max, tree) => Math.max(max, tree.id), 0);
-      forest = updated;
-      if (nextMaxId > lastMaxId) {
-        lastMaxId = nextMaxId;
-        await animateNewTree(forest, nextMaxId);
-      } else {
-        renderForest(forest);
+  // Check for changes — used by both fs.watch and polling fallback
+  async function checkForUpdates() {
+    if (animating) return;
+
+    if (ignoreNextChange) {
+      ignoreNextChange = false;
+      return;
+    }
+
+    const updated = readForest();
+    if (!updated) return;
+
+    // Only re-render if something actually changed
+    if (updated.totalPrompts === lastTotalPrompts) return;
+
+    const nextMaxId = updated.trees.reduce((max, tree) => Math.max(max, tree.id), 0);
+    forest = updated;
+    lastTotalPrompts = forest.totalPrompts;
+
+    if (nextMaxId > lastMaxId) {
+      lastMaxId = nextMaxId;
+      animating = true;
+      await animateNewTree(forest, nextMaxId);
+      animating = false;
+    } else {
+      renderForest(forest);
+    }
+  }
+
+  // fs.watch can drop events on macOS after atomic renames, so
+  // use it for fast response but also poll as a reliable fallback
+  function startWatcher() {
+    try {
+      const watcher = fs.watch(forestFile, () => {
+        checkForUpdates();
+      });
+      watcher.on("error", () => {});
+      return watcher;
+    } catch {
+      return null;
+    }
+  }
+
+  let watcher = startWatcher();
+
+  // Poll every 800ms as fallback — cheap since it only reads if mtime changed
+  let lastMtime = 0;
+  try {
+    lastMtime = fs.statSync(forestFile).mtimeMs;
+  } catch {}
+
+  setInterval(() => {
+    try {
+      const mtime = fs.statSync(forestFile).mtimeMs;
+      if (mtime !== lastMtime) {
+        lastMtime = mtime;
+        checkForUpdates();
+
+        // Re-establish watcher in case rename killed it
+        if (watcher) {
+          try { watcher.close(); } catch {}
+        }
+        watcher = startWatcher();
       }
-    }, 100);
-  });
+    } catch {}
+  }, 800);
 }