honeytree 1.0.6 → 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.6",
-  "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,44 +1,28 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { readForest } from "./state.js";
-import { buildScene, getWiltFactor } from "./renderer.js";
+import { readState } from "./core/state.js";
+import { buildTerminalScene } from "./renderers/terminal.js";
 
 const CELL = 6;
 const BG = "#0d1117";
 const TEXT_PAD = 18;
 
-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 escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 
-function generateForestSVG(forest) {
-  const cols = Math.max(40, Math.min(forest.viewerWidth || 60, 80));
-  const { buffer, biome, sceneRows } = buildScene(forest, cols);
+function generateForestSVG(state) {
+  const cols = 80;
+  const { buffer, statsLine } = buildTerminalScene(state, cols, 0, { color: false });
 
   const artW = cols * CELL;
-  const artH = sceneRows * CELL;
+  const artH = buffer.length * CELL;
   const totalW = artW;
   const totalH = artH + TEXT_PAD;
 
   let rects = "";
-  for (let y = 0; y < sceneRows; y += 1) {
+  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;
@@ -46,17 +30,15 @@ function generateForestSVG(forest) {
     }
   }
 
-  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">${stats}</text>
+<text x="${totalW / 2}" y="${artH + 13}" text-anchor="middle" fill="#8e8a84" font-family="monospace" font-size="10">${escapeXml(statsLine.trim())}</text>
 </svg>`;
 }
 
-export function writeBadgeSVG(forest, outPath) {
-  fs.writeFileSync(outPath, generateForestSVG(forest));
+export function writeBadgeSVG(state, outPath) {
+  fs.writeFileSync(outPath, generateForestSVG(state));
 }
 
 export function findBadgeFile() {
@@ -71,21 +53,14 @@ export function findBadgeFile() {
 }
 
 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 outPath = path.resolve("honeytree-badge.svg");
-  writeBadgeSVG(forest, outPath);
+  writeBadgeSVG(state, outPath);
 
   console.log(`Badge written to ${outPath}`);
-  console.log("");
-  console.log("Add this to your README to show your Honeytree forest.");
-  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));
+}
+

package/src/commands/watch.js

@@ -0,0 +1,117 @@
+import React, { useEffect, useMemo, useState } from "react";
+import { Box, Text, render, useApp, useInput, useStdout } from "ink";
+
+import { applyActiveMinutes, applyActivityPulse, applyCommit, applyFileSave } from "../core/progression.js";
+import { ensureState, readState, updateState } from "../core/state.js";
+import { renderTerminalFrame } from "../renderers/terminal.js";
+import { createActivityTracker } from "../tracker/activity.js";
+import { startFileTracker } from "../tracker/files.js";
+import { startGitTracker } from "../tracker/git.js";
+
+const FRAME_MS = 100;
+const POLL_MS = 1_000;
+const h = React.createElement;
+
+function buildCommandHint(width) {
+  const full = "init: honeytree init  ·  watch: honeydew watch";
+  const compact = "honeytree init  ·  honeydew watch";
+  if (width >= full.length + 2) {
+    return full;
+  }
+  return compact;
+}
+
+function ForestWatchApp() {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const [tick, setTick] = useState(0);
+  const [state, setState] = useState(() => ensureState());
+  const [width, setWidth] = useState(stdout.columns || 80);
+
+  useInput((input, key) => {
+    if (input === "q" || key.escape || key.ctrl && input === "c") {
+      exit();
+    }
+  });
+
+  useEffect(() => {
+    const onResize = () => setWidth(stdout.columns || 80);
+    stdout.on("resize", onResize);
+    return () => stdout.off("resize", onResize);
+  }, [stdout]);
+
+  useEffect(() => {
+    const frameTimer = setInterval(() => {
+      setTick((value) => value + 1);
+    }, FRAME_MS);
+    return () => clearInterval(frameTimer);
+  }, []);
+
+  useEffect(() => {
+    const syncTimer = setInterval(() => {
+      const latest = readState();
+      if (latest) {
+        setState(latest);
+      }
+    }, POLL_MS);
+    return () => clearInterval(syncTimer);
+  }, []);
+
+  useEffect(() => {
+    const activity = createActivityTracker({
+      onMinutes(minutes) {
+        const nextState = updateState((draft) => applyActiveMinutes(draft, { minutes, width }));
+        setState(nextState);
+      },
+    });
+    const stopActivity = activity.start();
+
+    const fileTracker = startFileTracker({
+      cwd: process.cwd(),
+      onSave() {
+        activity.markActive();
+        const nextState = updateState((draft) => {
+          applyActivityPulse(draft);
+          return applyFileSave(draft, { width });
+        });
+        setState(nextState);
+      },
+    });
+
+    const gitTracker = startGitTracker({
+      cwd: process.cwd(),
+      lastCommitHash: state.last_commit_hash,
+      async onCommit(commitHash) {
+        const nextState = updateState((draft) => applyCommit(draft, { commitHash, width }));
+        setState(nextState);
+      },
+    });
+
+    gitTracker.poll().catch(() => {});
+
+    return () => {
+      stopActivity();
+      fileTracker.close().catch?.(() => {});
+      gitTracker.stop();
+    };
+  }, [width]);
+
+  const frame = useMemo(
+    () => renderTerminalFrame(state, width, tick, { now: new Date() }),
+    [state, tick, width],
+  );
+  const commandHint = useMemo(() => buildCommandHint(width), [width]);
+
+  return h(
+    Box,
+    { flexDirection: "column" },
+    h(Text, null, frame),
+    h(Text, { color: "gray" }, commandHint),
+  );
+}
+
+export async function watch() {
+  ensureState();
+  const app = render(h(ForestWatchApp));
+  await app.waitUntilExit();
+}