honeytree 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,94 @@
+# 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.
+
+---
+
+## Quick Start
+
+```bash
+npm install -g honeytree
+honeytree init
+honeytree
+```
+
+That's it. Three commands:
+
+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
+
+After setup, trees are planted automatically after every Claude Code response. No manual steps needed.
+
+---
+
+## How It Works
+
+When you run `honeytree init`, it does two things:
+
+- Creates `~/.honeydew/forest.json` to store your forest state
+- Adds a `Stop` hook to `~/.claude/settings.json` that runs after every Claude Code response
+
+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.
+
+---
+
+## Biomes
+
+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 |
+| 50–99 | Old Growth | Deep greens, warm starlight |
+| 100+ | Ancient Forest | Richest palette, brightest sky |
+
+Trees are never deleted. The forest only grows.
+
+---
+
+## Tree Species
+
+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](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
+
+MIT

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "honeytree",
-  "version": "1.0.0",
-  "description": "Grow a pixel-art forest in your terminal every time you use Claude Code",
+  "version": "1.0.2",
+  "description": "Grow a forest in your terminal every time you use Claude Code",
   "type": "module",
   "bin": {
     "honeytree": "./bin/honeydew.js"
@@ -24,11 +24,11 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/varunnukala/honeytree.git"
+    "url": "git+https://github.com/Varun2009178/honeytree.git"
   },
-  "homepage": "https://github.com/varunnukala/honeytree#readme",
+  "homepage": "https://github.com/Varun2009178/honeytree#readme",
   "bugs": {
-    "url": "https://github.com/varunnukala/honeytree/issues"
+    "url": "https://github.com/Varun2009178/honeytree/issues"
   },
   "author": "Varun Nukala",
   "license": "MIT",

package/src/plant.js

@@ -1,8 +1,14 @@
 import { getSprite, TREE_TYPES } from "./sprites.js";
 import { createEmptyForest, readForest, writeForest } from "./state.js";
 
-const DEFAULT_WIDTH = 80;
 const MIN_GAP = 2;
+const DEFAULT_WIDTH = 80;
+
+function getPlantWidth(forest) {
+  // Use the width saved by the viewer, fall back to default
+  if (forest.viewerWidth && forest.viewerWidth > 40) return forest.viewerWidth;
+  return DEFAULT_WIDTH;
+}
 
 function randomItem(items) {
   return items[Math.floor(Math.random() * items.length)];
@@ -20,7 +26,7 @@ function occupiedRanges(trees) {
   });
 }
 
-function findOpenX(trees, type, growth) {
+function findOpenX(trees, type, growth, width) {
   const sprite = getSprite(type, growth);
   const half = Math.floor(sprite.width / 2);
   const margin = half + 1;
@@ -28,7 +34,7 @@ function findOpenX(trees, type, growth) {
 
   for (let attempt = 0; attempt < 100; attempt += 1) {
     const x =
-      margin + Math.floor(Math.random() * Math.max(1, DEFAULT_WIDTH - margin * 2));
+      margin + Math.floor(Math.random() * Math.max(1, width - margin * 2));
     const left = x - half;
     const right = x + half;
     const collides = ranges.some(
@@ -38,7 +44,7 @@ function findOpenX(trees, type, growth) {
     if (!collides) return x;
   }
 
-  return margin + Math.floor(Math.random() * Math.max(1, DEFAULT_WIDTH - margin * 2));
+  return margin + Math.floor(Math.random() * Math.max(1, width - margin * 2));
 }
 
 function nudgeGrowth(growth) {
@@ -49,6 +55,7 @@ function nudgeGrowth(growth) {
 
 export async function plant() {
   const forest = readForest() ?? createEmptyForest();
+  const width = getPlantWidth(forest);
 
   for (const tree of forest.trees) {
     tree.growth = nudgeGrowth(tree.growth);
@@ -62,7 +69,7 @@ export async function plant() {
     id: nextId,
     type,
     growth,
-    x: findOpenX(forest.trees, type, growth),
+    x: findOpenX(forest.trees, type, growth, width),
     plantedAt: new Date().toISOString(),
   });
   forest.totalPrompts += 1;

package/src/renderer.js

@@ -11,14 +11,59 @@ const STATS_ROWS = 1;
 export const SCENE_HEIGHT =
   SKY_ROWS + TREE_ROWS + GROUND_ROWS + SPACER_ROWS + STATS_ROWS;
 
-const STAR_GLYPHS = ["·", "·", "✦", "."];
-const GROUND_COLORS = ["#22492d", "#18361f"];
 const STATS_ACCENT = "#f5a50b";
 const STATS_TEXT = "#8e8a84";
 const BAR_FILL = "#6cb95e";
 const BAR_EMPTY = "#3d3d3d";
 const MILESTONES = [10, 25, 50, 100, 250, 500, 1000];
 
+// Biomes evolve as the forest grows — never resets, only gets richer
+const BIOMES = [
+  { // 0-9: sparse clearing
+    ground: ["#2a3a28", "#1e2d1c"],
+    starGlyphs: ["·", ".", " ", " "],
+    starDensity: 12,
+    starColors: ["#3a3a3a", "#444444"],
+    label: "clearing",
+  },
+  { // 10-24: young grove
+    ground: ["#22492d", "#18361f"],
+    starGlyphs: ["·", "·", "✦", "."],
+    starDensity: 9,
+    starColors: ["#444444", "#5d5d5d"],
+    label: "grove",
+  },
+  { // 25-49: dense woodland
+    ground: ["#1e4a28", "#163a1e"],
+    starGlyphs: ["·", "✦", "✧", "·", "."],
+    starDensity: 7,
+    starColors: ["#4d4d4d", "#5d5d5d", "#6a6a55"],
+    label: "woodland",
+  },
+  { // 50-99: old growth
+    ground: ["#1a5230", "#124020"],
+    starGlyphs: ["✦", "✧", "·", "·", "✦", "."],
+    starDensity: 6,
+    starColors: ["#5d5d5d", "#6d6d5a", "#7a7a60"],
+    label: "old growth",
+  },
+  { // 100+: ancient forest
+    ground: ["#165a32", "#0e4822"],
+    starGlyphs: ["✦", "✧", "·", "✦", "⋆", "."],
+    starDensity: 5,
+    starColors: ["#6d6d5a", "#7a7a60", "#8a8a6a"],
+    label: "ancient forest",
+  },
+];
+
+function getBiome(treeCount) {
+  if (treeCount < 10) return BIOMES[0];
+  if (treeCount < 25) return BIOMES[1];
+  if (treeCount < 50) return BIOMES[2];
+  if (treeCount < 100) return BIOMES[3];
+  return BIOMES[4];
+}
+
 function createBuffer(width) {
   return Array.from({ length: SCENE_HEIGHT }, () =>
     Array.from({ length: width }, () => ({ char: " ", color: null })),
@@ -32,16 +77,16 @@ function hash(seed) {
   return ((value >>> 16) ^ value) >>> 0;
 }
 
-function generateStars(width, twinkle = 0) {
+function generateStars(width, biome, twinkle = 0) {
   const stars = [];
   for (let x = 0; x < width; x += 1) {
     const seeded = hash(x + width * 17 + twinkle * 101);
-    if (seeded % 9 !== 0) continue;
+    if (seeded % biome.starDensity !== 0) continue;
     stars.push({
       x,
       y: seeded % SKY_ROWS,
-      char: STAR_GLYPHS[seeded % STAR_GLYPHS.length],
-      color: seeded % 3 === 0 ? "#5d5d5d" : "#444444",
+      char: biome.starGlyphs[seeded % biome.starGlyphs.length],
+      color: biome.starColors[seeded % biome.starColors.length],
     });
   }
   return stars;
@@ -78,7 +123,7 @@ function getDayCount(createdAt) {
   return Math.max(1, days + 1);
 }
 
-function buildStatsLine(forest) {
+function buildStatsLine(forest, biome) {
   const treeCount = forest.trees.length;
   const milestone = getNextMilestone(treeCount);
   const progress = milestone === 0 ? 0 : treeCount / milestone;
@@ -96,7 +141,8 @@ function buildStatsLine(forest) {
       )} day${getDayCount(forest.createdAt) === 1 ? "" : "s"} · `,
     ) +
     bar +
-    chalk.hex(STATS_TEXT)(` next: ${getNextTreeType(treeCount)}`)
+    chalk.hex(STATS_TEXT)(` next: ${getNextTreeType(treeCount)}`) +
+    chalk.hex("#555555")(` [${biome.label}]`)
   );
 }
 
@@ -104,8 +150,9 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
   const width = Math.max(40, termWidth);
   const buffer = createBuffer(width);
   const groundStart = SKY_ROWS + TREE_ROWS;
+  const biome = getBiome(forest.trees.length);
 
-  for (const star of generateStars(width, options.twinkleSeed ?? 0)) {
+  for (const star of generateStars(width, biome, options.twinkleSeed ?? 0)) {
     buffer[star.y][star.x] = { char: star.char, color: star.color };
   }
 
@@ -113,7 +160,7 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
     for (let x = 0; x < width; x += 1) {
       buffer[groundStart + rowIndex][x] = {
         char: "█",
-        color: GROUND_COLORS[rowIndex],
+        color: biome.ground[rowIndex],
       };
     }
   }
@@ -133,7 +180,7 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
   }
 
   lines.push("");
-  lines.push(buildStatsLine(forest));
+  lines.push(buildStatsLine(forest, biome));
 
   return lines.join("\n");
 }

package/src/viewer.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 
 import { renderFrame } from "./renderer.js";
-import { getForestFile, readForest } from "./state.js";
+import { getForestFile, readForest, writeForest } from "./state.js";
 
 function writeAnsi(code) {
   process.stdout.write(code);
@@ -63,11 +63,25 @@ export async function viewer() {
     process.exit(1);
   }
 
+  // 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);
+    }
+  }
+
+  syncWidth();
   hideCursor();
   clearScreen();
   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();
@@ -81,25 +95,75 @@ export async function viewer() {
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   process.stdout.on("resize", () => {
+    syncWidth();
     clearScreen();
     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);
 }