honeytree 1.0.5 → 1.0.7

package/README.md

@@ -1,192 +1,45 @@
 # 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)
+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.
 
-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
+## Install
 
 ```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)
 ```
 
-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.
+Run `honeytree` to open the forest. `honeydew watch` is kept as the explicit watch alias.
 
-| State | Badge color | Example |
-|-------|-------------|---------|
-| Active streak | Green | `42 trees · 7d streak` |
-| Wilting | Orange-red | `42 trees · wilting` |
-| No streak data | Grey | `42 trees` |
+## Commands
 
-Re-run `honeytree badge` any time to update the SVG with your latest stats. Commit it to your repo to keep it current.
+| 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 |
 
----
+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.
 
-## FOREST.md
+## What Grows
 
-Generate a shareable markdown snapshot of your forest:
-
-```bash
-honeytree 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.
 
-This creates a `FOREST.md` in your current directory with:
+## Visual System
 
-- 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 |
-
----
+- 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.
 
 ## 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)
+- VS Code 1.85+ for the bundled extension
 
 ## License
 

package/bin/honeydew.js

@@ -3,22 +3,19 @@
 const command = process.argv[2];
 
 if (command === "init") {
-  const { init } = await import("../src/init.js");
+  const { init } = await import("../src/commands/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 === "plant") {
-  const { plant } = await import("../src/plant.js");
+  const { plant } = await import("../src/commands/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}`);
-  console.error("Usage: honeytree [init|plant|badge|md]");
+  console.error("Usage: honeytree [init | export | watch]");
   process.exit(1);
 }

package/package.json

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

package/src/badge.js

@@ -1,92 +1,66 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { readForest } from "./state.js";
+import { readState } from "./core/state.js";
+import { buildTerminalScene } from "./renderers/terminal.js";
 
-const CHAR_WIDTH = 6.8;
-const PADDING = 10;
-const HEIGHT = 20;
+const CELL = 6;
+const BG = "#0d1117";
+const TEXT_PAD = 18;
 
-function sectionWidth(text) {
-  return Math.round(text.length * CHAR_WIDTH + PADDING * 2);
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 
-function buildMessage(forest) {
-  const count = forest.trees.length;
-  const streak = forest.streak || 0;
-  const treePart = `${count} tree${count === 1 ? "" : "s"}`;
+function generateForestSVG(state) {
+  const cols = 80;
+  const { buffer, statsLine } = buildTerminalScene(state, cols, 0, { color: false });
 
-  if (!forest.lastActiveDate) return treePart;
+  const artW = cols * CELL;
+  const artH = buffer.length * CELL;
+  const totalW = artW;
+  const totalH = artH + TEXT_PAD;
 
-  const today = new Date().toISOString().slice(0, 10);
-  const a = new Date(forest.lastActiveDate + "T00:00:00");
-  const b = new Date(today + "T00:00:00");
-  const idle = Math.round((b - a) / (24 * 60 * 60 * 1000));
+  let rects = "";
+  for (let y = 0; y < buffer.length; y += 1) {
+    for (let x = 0; x < cols; x += 1) {
+      const cell = buffer[y][x];
+      if (!cell.color) continue;
+      rects += `<rect x="${x * CELL}" y="${y * CELL}" width="${CELL}" height="${CELL}" fill="${cell.color}"/>`;
+    }
+  }
 
-  if (idle > 0) return `${treePart} · wilting`;
-  if (streak > 0) return `${treePart} · ${streak}d streak`;
-  return treePart;
+  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>
+</svg>`;
 }
 
-function badgeColor(forest) {
-  if (!forest.lastActiveDate) return "#555";
-  const today = new Date().toISOString().slice(0, 10);
-  const a = new Date(forest.lastActiveDate + "T00:00:00");
-  const b = new Date(today + "T00:00:00");
-  const idle = Math.round((b - a) / (24 * 60 * 60 * 1000));
-  if (idle > 0) return "#c4653a";
-  return "#2ea043";
+export function writeBadgeSVG(state, outPath) {
+  fs.writeFileSync(outPath, generateForestSVG(state));
 }
 
-function generateSVG(label, message, color) {
-  const lw = sectionWidth(label);
-  const mw = sectionWidth(message);
-  const tw = lw + mw;
-  const lx = lw / 2;
-  const mx = lw + mw / 2;
-
-  return `<svg xmlns="http://www.w3.org/2000/svg" width="${tw}" height="${HEIGHT}" role="img" aria-label="${label}: ${message}">
-  <title>${label}: ${message}</title>
-  <linearGradient id="s" x2="0" y2="100%">
-    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
-    <stop offset="1" stop-opacity=".1"/>
-  </linearGradient>
-  <clipPath id="r"><rect width="${tw}" height="${HEIGHT}" rx="3" fill="#fff"/></clipPath>
-  <g clip-path="url(#r)">
-    <rect width="${lw}" height="${HEIGHT}" fill="#555"/>
-    <rect x="${lw}" width="${mw}" height="${HEIGHT}" fill="${color}"/>
-    <rect width="${tw}" height="${HEIGHT}" fill="url(#s)"/>
-  </g>
-  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="11">
-    <text aria-hidden="true" x="${lx}" y="15" fill="#010101" fill-opacity=".3">${label}</text>
-    <text x="${lx}" y="14">${label}</text>
-    <text aria-hidden="true" x="${mx}" y="15" fill="#010101" fill-opacity=".3">${message}</text>
-    <text x="${mx}" y="14">${message}</text>
-  </g>
-</svg>`;
+export function findBadgeFile() {
+  let dir = process.cwd();
+  const root = path.parse(dir).root;
+  while (dir !== root) {
+    const candidate = path.join(dir, "honeytree-badge.svg");
+    if (fs.existsSync(candidate)) return candidate;
+    dir = path.dirname(dir);
+  }
+  return null;
 }
 
 export async function badge() {
-  const forest = readForest();
-  if (!forest) {
-    console.error('No forest found. Run "honeytree init" first.');
+  const state = readState();
+  if (!state) {
+    console.error('No Honeytree state found. Run "honeytree init" first.');
     process.exit(1);
   }
 
-  const label = "honeytree";
-  const message = buildMessage(forest);
-  const color = badgeColor(forest);
-  const svg = generateSVG(label, message, color);
-
   const outPath = path.resolve("honeytree-badge.svg");
-  fs.writeFileSync(outPath, svg);
+  writeBadgeSVG(state, outPath);
 
   console.log(`Badge written to ${outPath}`);
-  console.log("");
-  console.log("Add this to your README to show your Honeytree stats.");
-  console.log("The badge links to https://github.com/Varun2009178/honeytree");
-  console.log("");
-  console.log(
-    `[![honeytree](./honeytree-badge.svg)](https://github.com/Varun2009178/honeytree)`,
-  );
 }

package/src/commands/export.js

@@ -0,0 +1,23 @@
+import path from "node:path";
+
+import { writeBadgeSVG } from "../badge.js";
+import { buildMarkdown } from "../markdown.js";
+import { readState } from "../core/state.js";
+import fs from "node:fs";
+
+export async function exportForest() {
+  const state = readState();
+  if (!state) {
+    console.error('No Honeytree state found. Run "honeytree init" first.');
+    process.exit(1);
+  }
+
+  const badgePath = path.resolve("honeytree-badge.svg");
+  writeBadgeSVG(state, badgePath);
+
+  const md = buildMarkdown(state);
+  const mdPath = path.resolve("FOREST.md");
+  fs.writeFileSync(mdPath, md);
+
+  console.log("Exported honeytree-badge.svg and FOREST.md");
+}

package/src/commands/init.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { ensureState, getStateFile } from "../core/state.js";
+
+function getClaudeSettingsPath() {
+  const root = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+  return path.join(root, "settings.json");
+}
+
+function hasClaudeHook(settings) {
+  return (
+    settings?.hooks?.Stop?.some((entry) =>
+      entry?.hooks?.some((hook) => hook?.command === "honeytree plant"),
+    ) ?? false
+  );
+}
+
+function installClaudeHook() {
+  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 (!hasClaudeHook(settings)) {
+    settings.hooks.Stop.push({
+      matcher: "",
+      hooks: [{ type: "command", command: "honeytree plant" }],
+    });
+    fs.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+    return settingsPath;
+  }
+
+  return null;
+}
+
+export async function init() {
+  ensureState();
+
+  const hook = process.argv.includes("--hook") || process.env.HONEYTREE_ENABLE_CLAUDE_HOOK === "1";
+  if (hook) installClaudeHook();
+
+  const suffix = hook ? " (Claude hook installed)" : "";
+  console.log(`🌳 Forest planted at ${getStateFile()}${suffix}`);
+}

package/src/commands/plant.js

@@ -0,0 +1,12 @@
+import { applyCommit } from "../core/progression.js";
+import { updateState } from "../core/state.js";
+
+export async function plant() {
+  const width = Number.parseInt(process.env.HONEYTREE_WIDTH ?? "80", 10) || 80;
+  const now = new Date();
+  const nextState = updateState((state) => applyCommit(state, { now, width }));
+  console.log(
+    `Planted ${nextState.trees.at(-1)?.species ?? "tree"} #${nextState.total_commits} (${nextState.trees.length} total trees)`,
+  );
+}
+

package/src/commands/stats.js

@@ -0,0 +1,48 @@
+import { getEnvironmentSnapshot } from "../core/environment.js";
+import { getNextMinuteCheckpoint } from "../core/progression.js";
+import { getTreeSpeciesForCommit } from "../core/sprites.js";
+import { readState } from "../core/state.js";
+
+function formatPlural(count, singular) {
+  return `${count} ${singular}${count === 1 ? "" : "s"}`;
+}
+
+function getNextTreeCommit(totalCommits) {
+  return totalCommits + 1;
+}
+
+function getNextGroundUnlock(totalFileSaves) {
+  return Math.ceil((totalFileSaves + 1) / 50) * 50;
+}
+
+export function buildStatsReport(state, now = new Date()) {
+  const environment = getEnvironmentSnapshot(now, state.current_streak);
+  const nextTreeCommit = getNextTreeCommit(state.total_commits);
+  const nextGroundUnlock = getNextGroundUnlock(state.total_file_saves);
+  const nextMinuteUnlock = getNextMinuteCheckpoint(state.total_minutes_coded);
+
+  return [
+    "Honeytree",
+    `Trees: ${formatPlural(state.trees.length, "tree")} (${state.total_commits} commits)`,
+    `Animals: ${formatPlural(state.animals.length, "animal")} (${state.total_minutes_coded} active minutes)`,
+    `Ground: ${formatPlural(state.ground_elements.length, "element")} (${state.total_file_saves} file saves)`,
+    `Streak: ${state.current_streak} day${state.current_streak === 1 ? "" : "s"}`,
+    `Season: ${environment.season.label}`,
+    `Weather: ${environment.weather.label}`,
+    `Sky: ${environment.sky.label}`,
+    `Next tree: commit ${nextTreeCommit} → ${getTreeSpeciesForCommit(nextTreeCommit)}`,
+    `Next ground element: ${Math.max(0, nextGroundUnlock - state.total_file_saves)} saves`,
+    `Next animal: ${Math.max(0, nextMinuteUnlock - state.total_minutes_coded)} minutes`,
+  ].join("\n");
+}
+
+export async function stats() {
+  const state = readState();
+  if (!state) {
+    console.error('No Honeytree state found. Run "honeytree init" first.');
+    process.exit(1);
+  }
+
+  console.log(buildStatsReport(state));
+}
+