honeytree 1.1.4 → 1.1.5

package/README.md

@@ -1,45 +1,192 @@
 # Honeytree
 
-Honeytree is a living pixel-art forest for developers. It tracks git commits, file saves, and active coding time, then renders the result as a shared forest in the terminal and the VS Code sidebar.
+[![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)
 
-## Install
+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.
+
+---
+
+## Streaks
+
+Honeytree tracks your coding streak — consecutive days where you use Claude Code.
+
+- **Active streak**: The viewer and badge show your current streak count (e.g. `7-day streak`)
+- **Broken streak**: Miss a day and your forest starts **wilting** — trees desaturate toward brown, and fog rolls in across the scene
+- **Recovery**: Your next prompt resets the streak to 1 and clears the wilting immediately
+
+The longer you go without coding, the worse it gets:
+
+| Days idle | Effect |
+|----------:|--------|
+| 1 | Light desaturation, sparse fog |
+| 2 | Noticeable browning, moderate fog |
+| 3 | Heavy browning, dense fog |
+| 4+ | Near-dead forest, thick fog |
+
+Plant a tree to bring it all back to life.
+
+---
+
+## Badge
+
+Generate a badge for your GitHub README that shows your forest stats and links back to [Honeytree](https://github.com/Varun2009178/honeytree):
+
+```bash
+honeytree badge
+```
+
+This creates a `honeytree-badge.svg` file in your current directory and prints the markdown to embed it:
+
+```markdown
+[![honeytree](./honeytree-badge.svg)](https://github.com/Varun2009178/honeytree)
 ```
 
-Run `honeytree` to open the forest. `honeydew watch` is kept as the explicit watch alias.
+The badge displays your tree count and streak status. It links to the [Honeytree repo](https://github.com/Varun2009178/honeytree) so anyone who sees it can install it themselves.
 
-## Commands
+| State | Badge color | Example |
+|-------|-------------|---------|
+| Active streak | Green | `42 trees · 7d streak` |
+| Wilting | Orange-red | `42 trees · wilting` |
+| No streak data | Grey | `42 trees` |
 
-| Command | What it does |
-| --- | --- |
-| `honeytree init` | Creates `~/.honeytree/state.json`, migrates old `~/.honeydew/forest.json`, and prepares the forest project |
-| `honeytree` | Opens the animated terminal forest |
-| `honeydew watch` | Explicit watch alias for the same forest view |
+Re-run `honeytree badge` any time to update the SVG with your latest stats. Commit it to your repo to keep it current.
 
-Internal compatibility commands such as `plant`, `stats`, `badge`, and `md` still exist for integration flows, but they are not part of the primary public workflow.
+---
 
-## What Grows
+## FOREST.md
 
-- Git commits plant trees.
-- Every 50 file saves adds a ground element.
-- Every 30 active coding minutes adds an animal.
-- Your streak drives weather effects.
-- The current month drives the season.
+Generate a shareable markdown snapshot of your forest:
+
+```bash
+honeytree md
+```
 
-## Visual System
+This creates a `FOREST.md` in your current directory with:
 
-- Time of day changes the sky between sunrise, day, sunset, and night.
-- Seasons recolor the same pixel sprites for spring, summer, autumn, and winter.
-- Weather escalates from clear to rain, rainbow, golden hour, and aurora.
-- The terminal uses Unicode pixel blocks, while the VS Code extension uses an animated canvas renderer.
+- Your Honeytree badge (links to the [Honeytree repo](https://github.com/Varun2009178/honeytree))
+- Stats: tree count, streak, biome
+- A plain-text rendering of your forest (tree silhouettes, stars, ground)
+- Total prompts and forest age
+
+Commit `FOREST.md` to your repo root so your team can see the forest. When teammates see it, they can install Honeytree themselves — one install spreads to the whole team.
+
+Run `honeytree badge` first to generate the SVG, then `honeytree md` to generate the markdown that embeds it.
+
+---
+
+## 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.
+
+---
+
+## CLI Reference
+
+| Command | Description |
+|---------|-------------|
+| `honeytree init` | Create forest and register Claude Code hook |
+| `honeytree` | Launch the live viewer |
+| `honeytree plant` | Plant a tree manually (normally runs via hook) |
+| `honeytree badge` | Generate `honeytree-badge.svg` in current directory |
+| `honeytree md` | Generate `FOREST.md` in current directory |
+
+---
+
+## 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.
+
+### Reading the Stats Bar
+
+Below your forest you'll see a stats bar like this:
+
+```
+ honeytree · 42 trees · 7-day streak · ████████░░░░ next: oak [woodland]
+```
+
+Here's what each part means:
+
+| Segment | What it tells you |
+|---------|-------------------|
+| `42 trees` | Total trees in your forest — one planted per prompt, never deleted |
+| `7-day streak` | Consecutive days you've used Claude Code. Resets to 1 if you skip a day |
+| `wilting (2d idle)` | Appears instead of streak when you've been inactive — your forest is dying |
+| `████████░░░░` | Progress bar toward the next milestone (10, 25, 50, 100, 250, 500, 1000 trees) |
+| `next: oak` | The species of the next tree that will be planted |
+| `[woodland]` | Your current biome — evolves as your tree count grows |
+
+---
 
 ## Requirements
 
 - Node.js 18+
-- VS Code 1.85+ for the bundled extension
+- [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/bin/honeydew.js

@@ -1,39 +1,24 @@
 #!/usr/bin/env node
 
-import path from "node:path";
-
 const command = process.argv[2];
-const invokedAs = path.basename(process.argv[1] || "honeytree");
-
-function printUsage() {
-  console.error("Usage:");
-  console.error("  honeytree          show your forest");
-  console.error("  honeytree init     create or migrate your forest");
-  console.error("  honeytree watch    open the terminal forest");
-  console.error("  honeytree stats    show a non-TUI summary");
-  console.error("  honeytree export   write honeytree-badge.svg and FOREST.md");
-}
 
 if (command === "init") {
-  const { init } = await import("../src/commands/init.js");
+  const { init } = await import("../src/init.js");
   await init();
-} else if (command === "export") {
-  const { exportForest } = await import("../src/commands/export.js");
-  await exportForest();
-} else if (command === "watch" || !command) {
-  const { watch } = await import("../src/commands/watch.js");
-  await watch();
-} else if (command === "stats") {
-  const { stats } = await import("../src/commands/stats.js");
-  await stats();
 } else if (command === "plant") {
-  const { plant } = await import("../src/commands/plant.js");
+  const { plant } = await import("../src/plant.js");
   await plant();
+} else if (command === "badge") {
+  const { badge } = await import("../src/badge.js");
+  await badge();
+} else if (command === "md") {
+  const { generateForestMd } = await import("../src/markdown.js");
+  await generateForestMd();
+} else if (!command) {
+  const { viewer } = await import("../src/viewer.js");
+  await viewer();
 } else {
   console.error(`Unknown command: ${command}`);
-  if (invokedAs === "honeydew") {
-    console.error("Run `honeydew watch` or `honeytree init`.");
-  }
-  printUsage();
+  console.error("Usage: honeytree [init|plant|badge|md]");
   process.exit(1);
 }

package/package.json

@@ -1,28 +1,26 @@
 {
   "name": "honeytree",
-  "version": "1.1.4",
-  "description": "A living pixel art forest that grows while you code",
+  "version": "1.1.5",
+  "description": "Grow a forest in your terminal every time you use Claude Code",
   "type": "module",
   "bin": {
-    "honeytree": "./bin/honeydew.js",
-    "honeydew": "./bin/honeydew.js"
+    "honeytree": "./bin/honeydew.js"
   },
   "files": [
     "bin",
     "src"
   ],
   "scripts": {
-    "test": "node --test test/**/*.test.js",
-    "postinstall": "echo \"🌳 Thanks for planting! Star us: https://github.com/Varun2009178/honeytree\""
+    "test": "node --test test/*.test.js"
   },
   "keywords": [
     "cli",
     "terminal",
     "forest",
+    "claude-code",
     "pixel-art",
-    "git",
-    "developer-tools",
-    "ascii-art"
+    "ascii-art",
+    "hooks"
   ],
   "repository": {
     "type": "git",
@@ -35,12 +33,7 @@
   "author": "Varun Nukala",
   "license": "MIT",
   "dependencies": {
-    "chalk": "^5.4.1",
-    "chokidar": "^4.0.3",
-    "date-fns": "^4.1.0",
-    "ink": "^5.2.1",
-    "react": "^18.3.1",
-    "simple-git": "^3.36.0"
+    "chalk": "^5.4.1"
   },
   "engines": {
     "node": ">=18"

package/src/badge.js

@@ -1,28 +1,44 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { readState } from "./core/state.js";
-import { buildTerminalScene } from "./renderers/terminal.js";
+import { readForest } from "./state.js";
+import { buildScene, getWiltFactor } from "./renderer.js";
 
 const CELL = 6;
 const BG = "#0d1117";
 const TEXT_PAD = 18;
 
-function escapeXml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+function buildStatsText(forest, biome) {
+  const count = forest.trees.length;
+  const streak = forest.streak || 0;
+  const wilt = getWiltFactor(forest.lastActiveDate);
+
+  const parts = [`${count} tree${count === 1 ? "" : "s"}`];
+
+  if (wilt > 0) {
+    const a = new Date(forest.lastActiveDate + "T00:00:00");
+    const b = new Date(new Date().toISOString().slice(0, 10) + "T00:00:00");
+    const idle = Math.round((b - a) / (24 * 60 * 60 * 1000));
+    parts.push(`wilting (${idle}d idle)`);
+  } else if (streak > 0) {
+    parts.push(`${streak}d streak`);
+  }
+
+  parts.push(biome.label);
+  return parts.join(" · ");
 }
 
-function generateForestSVG(state) {
-  const cols = 80;
-  const { buffer, statsLine } = buildTerminalScene(state, cols, 0, { color: false });
+function generateForestSVG(forest) {
+  const cols = Math.max(40, Math.min(forest.viewerWidth || 60, 80));
+  const { buffer, biome, sceneRows } = buildScene(forest, cols);
 
   const artW = cols * CELL;
-  const artH = buffer.length * CELL;
+  const artH = sceneRows * CELL;
   const totalW = artW;
   const totalH = artH + TEXT_PAD;
 
   let rects = "";
-  for (let y = 0; y < buffer.length; y += 1) {
+  for (let y = 0; y < sceneRows; y += 1) {
     for (let x = 0; x < cols; x += 1) {
       const cell = buffer[y][x];
       if (!cell.color) continue;
@@ -30,15 +46,17 @@ function generateForestSVG(state) {
     }
   }
 
+  const stats = buildStatsText(forest, biome);
+
   return `<svg xmlns="http://www.w3.org/2000/svg" width="${totalW}" height="${totalH}" viewBox="0 0 ${totalW} ${totalH}">
 <rect width="${totalW}" height="${totalH}" fill="${BG}" rx="6"/>
 ${rects}
-<text x="${totalW / 2}" y="${artH + 13}" text-anchor="middle" fill="#8e8a84" font-family="monospace" font-size="10">${escapeXml(statsLine.trim())}</text>
+<text x="${totalW / 2}" y="${artH + 13}" text-anchor="middle" fill="#8e8a84" font-family="monospace" font-size="10">${stats}</text>
 </svg>`;
 }
 
-export function writeBadgeSVG(state, outPath) {
-  fs.writeFileSync(outPath, generateForestSVG(state));
+export function writeBadgeSVG(forest, outPath) {
+  fs.writeFileSync(outPath, generateForestSVG(forest));
 }
 
 export function findBadgeFile() {
@@ -53,14 +71,14 @@ export function findBadgeFile() {
 }
 
 export async function badge() {
-  const state = readState();
-  if (!state) {
-    console.error('No Honeytree state found. Run "honeytree init" first.');
+  const forest = readForest();
+  if (!forest) {
+    console.error('No forest found. Run "honeytree init" first.');
     process.exit(1);
   }
 
   const outPath = path.resolve("honeytree-badge.svg");
-  writeBadgeSVG(state, outPath);
+  writeBadgeSVG(forest, outPath);
 
   console.log(`Badge written to ${outPath}`);
   console.log("");

package/src/init.js

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  createEmptyForest,
+  getHoneydewDir,
+  readForest,
+  writeForest,
+} from "./state.js";
+
+function getClaudeSettingsPath() {
+  const claudeRoot =
+    process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+  return path.join(claudeRoot, "settings.json");
+}
+
+const HONEYDEW_STOP_HOOK = {
+  matcher: "",
+  hooks: [
+    {
+      type: "command",
+      command: "honeytree plant",
+    },
+  ],
+};
+
+function hasHoneydewHook(settings) {
+  return (
+    settings?.hooks?.Stop?.some((entry) =>
+      entry?.hooks?.some((hook) => hook?.command === "honeytree plant"),
+    ) ?? false
+  );
+}
+
+export async function init() {
+  const honeydewDir = getHoneydewDir();
+  fs.mkdirSync(honeydewDir, { recursive: true });
+
+  const existing = readForest();
+  if (!existing) {
+    writeForest(createEmptyForest());
+    console.log(`Created ${path.join(honeydewDir, "forest.json")}`);
+  } else {
+    let migrated = false;
+    if (existing.lastActiveDate === undefined) {
+      existing.lastActiveDate = new Date().toISOString().slice(0, 10);
+      migrated = true;
+    }
+    if (existing.streak === undefined) {
+      existing.streak = 0;
+      migrated = true;
+    }
+    if (migrated) {
+      writeForest(existing);
+      console.log(`Updated forest with streak tracking (${existing.trees.length} trees kept)`);
+    } else {
+      console.log(`Forest already up to date at ${path.join(honeydewDir, "forest.json")}`);
+    }
+  }
+
+  const settingsPath = getClaudeSettingsPath();
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+
+  let settings = {};
+  try {
+    settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+  } catch {
+    settings = {};
+  }
+
+  settings.hooks ??= {};
+  settings.hooks.Stop ??= [];
+
+  if (hasHoneydewHook(settings)) {
+    console.log(`Claude Code hook already configured in ${settingsPath}`);
+  } else {
+    settings.hooks.Stop.push(HONEYDEW_STOP_HOOK);
+    fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+    console.log(`Added honeytree Stop hook to ${settingsPath}`);
+  }
+
+  console.log("");
+  console.log("Setup complete.");
+  console.log("Run `honeytree` in a separate terminal to watch the forest grow.");
+}

package/src/markdown.js

@@ -1,28 +1,58 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { getEnvironmentSnapshot } from "./core/environment.js";
-import { readState } from "./core/state.js";
-import { renderTerminalFrame } from "./renderers/terminal.js";
+import { readForest } from "./state.js";
+import { renderPlainText, getWiltFactor } from "./renderer.js";
 
-function buildMarkdown(state) {
-  const environment = getEnvironmentSnapshot(new Date(), state.current_streak);
-  const art = renderTerminalFrame(state, 80, 0, { color: false });
+function getBiomeLabel(count) {
+  if (count < 10) return "clearing";
+  if (count < 25) return "grove";
+  if (count < 50) return "woodland";
+  if (count < 100) return "old growth";
+  return "ancient forest";
+}
+
+function getDayCount(createdAt) {
+  const created = new Date(createdAt).getTime();
+  const diff = Date.now() - created;
+  return Math.max(1, Math.floor(diff / (24 * 60 * 60 * 1000)) + 1);
+}
+
+function buildMarkdown(forest) {
+  const count = forest.trees.length;
+  const streak = forest.streak || 0;
+  const biome = getBiomeLabel(count);
+  const wilt = getWiltFactor(forest.lastActiveDate);
+  const days = getDayCount(forest.createdAt);
+  const width = Math.min(forest.viewerWidth || 60, 80);
+
+  const art = renderPlainText(forest, width);
+
+  const statParts = [`**${count} tree${count === 1 ? "" : "s"}**`];
+  if (wilt > 0) {
+    const a = new Date(forest.lastActiveDate + "T00:00:00");
+    const b = new Date(new Date().toISOString().slice(0, 10) + "T00:00:00");
+    const idle = Math.round((b - a) / (24 * 60 * 60 * 1000));
+    statParts.push(`**wilting (${idle}d idle)**`);
+  } else if (streak > 0) {
+    statParts.push(`**${streak}-day streak**`);
+  }
+  statParts.push(`**${biome}**`);
 
   const lines = [
     `<div align="center">`,
     ``,
     `[![honeytree](./honeytree-badge.svg)](https://github.com/Varun2009178/honeytree)`,
     ``,
-    `**${state.trees.length} trees** · **${state.animals.length} animals** · **${state.current_streak} day streak** · **${environment.season.label} ${environment.weather.label}**`,
+    statParts.join(" · "),
     ``,
     "```",
     art,
     "```",
     ``,
-    `${state.total_commits} commits · ${state.total_file_saves} saves · ${state.total_minutes_coded} active minutes`,
+    `${forest.totalPrompts} prompts over ${days} day${days === 1 ? "" : "s"}`,
     ``,
-    `<sub>Grown with <a href="https://github.com/Varun2009178/honeytree">honeytree</a> — a living pixel forest that grows while you code</sub>`,
+    `<sub>Grown with <a href="https://github.com/Varun2009178/honeytree">honeytree</a> — a forest that grows in your terminal every time you use Claude Code</sub>`,
     ``,
     `</div>`,
     ``,
@@ -32,13 +62,13 @@ function buildMarkdown(state) {
 }
 
 export async function generateForestMd() {
-  const state = readState();
-  if (!state) {
-    console.error('No Honeytree state found. Run "honeytree init" first.');
+  const forest = readForest();
+  if (!forest) {
+    console.error('No forest found. Run "honeytree init" first.');
     process.exit(1);
   }
 
-  const md = buildMarkdown(state);
+  const md = buildMarkdown(forest);
   const outPath = path.resolve("FOREST.md");
   fs.writeFileSync(outPath, md);