honeytree 0.1.0

package/bin/honeydew.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+const command = process.argv[2];
+
+if (command === "init") {
+  const { init } = await import("../src/init.js");
+  await init();
+} else if (command === "plant") {
+  const { plant } = await import("../src/plant.js");
+  await plant();
+} else if (!command) {
+  const { viewer } = await import("../src/viewer.js");
+  await viewer();
+} else {
+  console.error(`Unknown command: ${command}`);
+  console.error("Usage: honeytree [init|plant]");
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "honeytree",
+  "version": "0.1.0",
+  "description": "Grow a pixel-art forest in your terminal every time you use Claude Code",
+  "type": "module",
+  "bin": {
+    "honeytree": "./bin/honeydew.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "keywords": [
+    "cli",
+    "terminal",
+    "forest",
+    "claude-code",
+    "pixel-art",
+    "ascii-art",
+    "hooks"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/varunnukala/honeytree.git"
+  },
+  "homepage": "https://github.com/varunnukala/honeytree#readme",
+  "bugs": {
+    "url": "https://github.com/varunnukala/honeytree/issues"
+  },
+  "author": "Varun Nukala",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.4.1"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/init.js

@@ -0,0 +1,71 @@
+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 });
+
+  if (!readForest()) {
+    writeForest(createEmptyForest());
+    console.log(`Created ${path.join(honeydewDir, "forest.json")}`);
+  } else {
+    console.log(`Forest already exists 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/plant.js

@@ -0,0 +1,71 @@
+import { getSprite, TREE_TYPES } from "./sprites.js";
+import { createEmptyForest, readForest, writeForest } from "./state.js";
+
+const DEFAULT_WIDTH = 80;
+const MIN_GAP = 2;
+
+function randomItem(items) {
+  return items[Math.floor(Math.random() * items.length)];
+}
+
+function randomGrowth() {
+  return Math.round((0.3 + Math.random() * 0.7) * 100) / 100;
+}
+
+function occupiedRanges(trees) {
+  return trees.map((tree) => {
+    const sprite = getSprite(tree.type, tree.growth);
+    const half = Math.floor(sprite.width / 2);
+    return [tree.x - half - MIN_GAP, tree.x + half + MIN_GAP];
+  });
+}
+
+function findOpenX(trees, type, growth) {
+  const sprite = getSprite(type, growth);
+  const half = Math.floor(sprite.width / 2);
+  const margin = half + 1;
+  const ranges = occupiedRanges(trees);
+
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    const x =
+      margin + Math.floor(Math.random() * Math.max(1, DEFAULT_WIDTH - margin * 2));
+    const left = x - half;
+    const right = x + half;
+    const collides = ranges.some(
+      ([occupiedLeft, occupiedRight]) =>
+        left < occupiedRight && right > occupiedLeft,
+    );
+    if (!collides) return x;
+  }
+
+  return margin + Math.floor(Math.random() * Math.max(1, DEFAULT_WIDTH - margin * 2));
+}
+
+function nudgeGrowth(growth) {
+  if (growth >= 1) return 1;
+  const nextGrowth = growth + 0.1 + Math.random() * 0.1;
+  return Math.min(1, Math.round(nextGrowth * 100) / 100);
+}
+
+export async function plant() {
+  const forest = readForest() ?? createEmptyForest();
+
+  for (const tree of forest.trees) {
+    tree.growth = nudgeGrowth(tree.growth);
+  }
+
+  const type = randomItem(TREE_TYPES);
+  const growth = randomGrowth();
+  const nextId = forest.trees.reduce((max, tree) => Math.max(max, tree.id), 0) + 1;
+
+  forest.trees.push({
+    id: nextId,
+    type,
+    growth,
+    x: findOpenX(forest.trees, type, growth),
+    plantedAt: new Date().toISOString(),
+  });
+  forest.totalPrompts += 1;
+
+  writeForest(forest);
+}

package/src/renderer.js

@@ -0,0 +1,139 @@
+import chalk from "chalk";
+
+import { getSprite, TREE_TYPES } from "./sprites.js";
+
+const SKY_ROWS = 4;
+const TREE_ROWS = 7;
+const GROUND_ROWS = 2;
+const SPACER_ROWS = 1;
+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];
+
+function createBuffer(width) {
+  return Array.from({ length: SCENE_HEIGHT }, () =>
+    Array.from({ length: width }, () => ({ char: " ", color: null })),
+  );
+}
+
+function hash(seed) {
+  let value = seed >>> 0;
+  value = Math.imul((value >>> 16) ^ value, 0x45d9f3b) >>> 0;
+  value = Math.imul((value >>> 16) ^ value, 0x45d9f3b) >>> 0;
+  return ((value >>> 16) ^ value) >>> 0;
+}
+
+function generateStars(width, 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;
+    stars.push({
+      x,
+      y: seeded % SKY_ROWS,
+      char: STAR_GLYPHS[seeded % STAR_GLYPHS.length],
+      color: seeded % 3 === 0 ? "#5d5d5d" : "#444444",
+    });
+  }
+  return stars;
+}
+
+function compositeSprite(buffer, sprite, centerX, baseY) {
+  const offsetX = centerX - Math.floor(sprite.width / 2);
+  for (let rowIndex = 0; rowIndex < sprite.rows.length; rowIndex += 1) {
+    const targetY = baseY - rowIndex;
+    if (targetY < 0 || targetY >= buffer.length) continue;
+    const row = sprite.rows[rowIndex];
+    for (let columnIndex = 0; columnIndex < row.length; columnIndex += 1) {
+      const targetX = offsetX + columnIndex;
+      if (targetX < 0 || targetX >= buffer[0].length) continue;
+      const [char, color] = row[columnIndex];
+      if (!color) continue;
+      buffer[targetY][targetX] = { char, color };
+    }
+  }
+}
+
+function getNextMilestone(treeCount) {
+  return MILESTONES.find((value) => treeCount < value) ?? treeCount + 100;
+}
+
+function getNextTreeType(treeCount) {
+  return TREE_TYPES[treeCount % TREE_TYPES.length];
+}
+
+function getDayCount(createdAt) {
+  const created = new Date(createdAt).getTime();
+  const diff = Date.now() - created;
+  const days = Math.floor(diff / (24 * 60 * 60 * 1000));
+  return Math.max(1, days + 1);
+}
+
+function buildStatsLine(forest) {
+  const treeCount = forest.trees.length;
+  const milestone = getNextMilestone(treeCount);
+  const progress = milestone === 0 ? 0 : treeCount / milestone;
+  const barWidth = 12;
+  const filledWidth = Math.max(0, Math.min(barWidth, Math.round(progress * barWidth)));
+  const bar =
+    chalk.hex(BAR_FILL)("█".repeat(filledWidth)) +
+    chalk.hex(BAR_EMPTY)("░".repeat(barWidth - filledWidth));
+
+  return (
+    chalk.hex(STATS_ACCENT)(" honeytree") +
+    chalk.hex(STATS_TEXT)(
+      ` · ${treeCount} tree${treeCount === 1 ? "" : "s"} · ${getDayCount(
+        forest.createdAt,
+      )} day${getDayCount(forest.createdAt) === 1 ? "" : "s"} · `,
+    ) +
+    bar +
+    chalk.hex(STATS_TEXT)(` next: ${getNextTreeType(treeCount)}`)
+  );
+}
+
+export function renderFrame(forest, termWidth = 80, options = {}) {
+  const width = Math.max(40, termWidth);
+  const buffer = createBuffer(width);
+  const groundStart = SKY_ROWS + TREE_ROWS;
+
+  for (const star of generateStars(width, options.twinkleSeed ?? 0)) {
+    buffer[star.y][star.x] = { char: star.char, color: star.color };
+  }
+
+  for (let rowIndex = 0; rowIndex < GROUND_ROWS; rowIndex += 1) {
+    for (let x = 0; x < width; x += 1) {
+      buffer[groundStart + rowIndex][x] = {
+        char: "█",
+        color: GROUND_COLORS[rowIndex],
+      };
+    }
+  }
+
+  const treeBaseY = groundStart - 1;
+  for (const tree of forest.trees) {
+    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY);
+  }
+
+  const lines = [];
+  for (let y = 0; y < SCENE_HEIGHT - SPACER_ROWS - STATS_ROWS; y += 1) {
+    let line = "";
+    for (const cell of buffer[y]) {
+      line += cell.color ? chalk.hex(cell.color)(cell.char) : cell.char;
+    }
+    lines.push(line);
+  }
+
+  lines.push("");
+  lines.push(buildStatsLine(forest));
+
+  return lines.join("\n");
+}

package/src/sprites.js

@@ -0,0 +1,245 @@
+export const TREE_TYPES = ["oak", "pine", "birch", "willow", "cherry"];
+
+const COLORS = {
+  canopyDark: "#3f7132",
+  canopyMid: "#5b9a4a",
+  canopyLight: "#7cc96a",
+  canopyDeep: "#2d5b29",
+  canopyBright: "#a4e28d",
+  trunkDark: "#6f4c2f",
+  trunkMid: "#8e6238",
+  trunkLight: "#b18552",
+  birchTrunk: "#d9d6d2",
+  cherryPink: "#de93b8",
+  cherryBloom: "#f0b7cf",
+};
+
+function parse(template, palette) {
+  const lines = template.trim().split("\n");
+  const width = Math.max(...lines.map((line) => line.length));
+  const rows = lines
+    .map((line) => line.padEnd(width, " "))
+    .map((line) =>
+      Array.from(line, (token) => {
+        const color = palette[token] ?? null;
+        return color ? ["█", color] : [" ", null];
+      }),
+    )
+    .reverse();
+
+  return { rows, width };
+}
+
+const SPRITES = {
+  oak: {
+    seed: parse(
+      `
+ g
+ t
+`,
+      { g: COLORS.canopyMid, t: COLORS.trunkMid },
+    ),
+    sapling: parse(
+      `
+ gg
+ggg
+ t
+`,
+      { g: COLORS.canopyMid, t: COLORS.trunkMid },
+    ),
+    young: parse(
+      `
+  gg
+ gGGg
+ggGGgg
+  tt
+  tt
+`,
+      { g: COLORS.canopyMid, G: COLORS.canopyDark, t: COLORS.trunkMid },
+    ),
+    full: parse(
+      `
+   gg
+ gGGGG
+ggGGGGgg
+ gGGGGg
+   tt
+   tt
+`,
+      { g: COLORS.canopyMid, G: COLORS.canopyDark, t: COLORS.trunkMid },
+    ),
+  },
+  pine: {
+    seed: parse(
+      `
+ g
+ t
+`,
+      { g: COLORS.canopyDeep, t: COLORS.trunkDark },
+    ),
+    sapling: parse(
+      `
+  g
+ gg
+ggg
+ t
+`,
+      { g: COLORS.canopyDeep, t: COLORS.trunkDark },
+    ),
+    young: parse(
+      `
+   g
+  ggg
+ gGGGg
+ggGGGG
+   t
+   t
+`,
+      { g: COLORS.canopyDeep, G: COLORS.canopyDark, t: COLORS.trunkDark },
+    ),
+    full: parse(
+      `
+    g
+   ggg
+  gGGGg
+ gGGGGGg
+ggGGGGGG
+ gGGGGG
+    t
+    t
+`,
+      { g: COLORS.canopyDeep, G: COLORS.canopyDark, t: COLORS.trunkDark },
+    ),
+  },
+  birch: {
+    seed: parse(
+      `
+ g
+ b
+`,
+      { g: COLORS.canopyLight, b: COLORS.birchTrunk },
+    ),
+    sapling: parse(
+      `
+ gg
+ghg
+ b
+`,
+      { g: COLORS.canopyLight, h: COLORS.canopyBright, b: COLORS.birchTrunk },
+    ),
+    young: parse(
+      `
+  hg
+ hggg
+ggghhg
+  bb
+  bb
+`,
+      { g: COLORS.canopyLight, h: COLORS.canopyBright, b: COLORS.birchTrunk },
+    ),
+    full: parse(
+      `
+   hh
+ hgggh
+ggghhgg
+ hgggh
+   bb
+   bb
+`,
+      { g: COLORS.canopyLight, h: COLORS.canopyBright, b: COLORS.birchTrunk },
+    ),
+  },
+  willow: {
+    seed: parse(
+      `
+ g
+ t
+`,
+      { g: COLORS.canopyLight, t: COLORS.trunkMid },
+    ),
+    sapling: parse(
+      `
+ ggg
+ggggg
+ ttt
+`,
+      { g: COLORS.canopyLight, t: COLORS.trunkMid },
+    ),
+    young: parse(
+      `
+  gggg
+ gggggg
+gg ggg gg
+gg     gg
+   tt
+   tt
+`,
+      { g: COLORS.canopyLight, t: COLORS.trunkMid },
+    ),
+    full: parse(
+      `
+   ggggg
+ gggggggg
+gg ggggg gg
+gg  ggg  gg
+gg       gg
+    tt
+    tt
+`,
+      { g: COLORS.canopyLight, t: COLORS.trunkMid },
+    ),
+  },
+  cherry: {
+    seed: parse(
+      `
+ p
+ t
+`,
+      { p: COLORS.cherryPink, t: COLORS.trunkLight },
+    ),
+    sapling: parse(
+      `
+ pp
+pPp
+ t
+`,
+      { p: COLORS.cherryBloom, P: COLORS.cherryPink, t: COLORS.trunkLight },
+    ),
+    young: parse(
+      `
+  pP
+ pPPp
+pPPpPP
+  tt
+  tt
+`,
+      { p: COLORS.cherryBloom, P: COLORS.cherryPink, t: COLORS.trunkLight },
+    ),
+    full: parse(
+      `
+   pPp
+ pPPPPp
+pPPpPPPp
+ pPPPpp
+   tt
+   tt
+`,
+      { p: COLORS.cherryBloom, P: COLORS.cherryPink, t: COLORS.trunkLight },
+    ),
+  },
+};
+
+function getGrowthStage(growth) {
+  if (growth < 0.2) return "seed";
+  if (growth < 0.5) return "sapling";
+  if (growth < 0.8) return "young";
+  return "full";
+}
+
+export function getSprite(type, growth) {
+  const spriteSet = SPRITES[type];
+  if (!spriteSet) {
+    throw new Error(`Unknown tree type: ${type}`);
+  }
+  return spriteSet[getGrowthStage(growth)];
+}

package/src/state.js

@@ -0,0 +1,51 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+function resolveHoneydewDir() {
+  return process.env.HONEYDEW_DIR || path.join(os.homedir(), ".honeydew");
+}
+
+function resolveForestFile() {
+  return path.join(resolveHoneydewDir(), "forest.json");
+}
+
+export const HONEYDEW_DIR = resolveHoneydewDir();
+export const FOREST_FILE = resolveForestFile();
+
+export function getHoneydewDir() {
+  return resolveHoneydewDir();
+}
+
+export function getForestFile() {
+  return resolveForestFile();
+}
+
+export function createEmptyForest() {
+  return {
+    trees: [],
+    totalPrompts: 0,
+    createdAt: new Date().toISOString(),
+  };
+}
+
+export function readForest() {
+  try {
+    return JSON.parse(fs.readFileSync(resolveForestFile(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function writeForest(state) {
+  const dir = resolveHoneydewDir();
+  const file = resolveForestFile();
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpFile = path.join(
+    dir,
+    `forest.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`,
+  );
+  fs.writeFileSync(tmpFile, JSON.stringify(state, null, 2));
+  fs.renameSync(tmpFile, file);
+}

package/src/viewer.js

@@ -0,0 +1,105 @@
+import fs from "node:fs";
+
+import { renderFrame } from "./renderer.js";
+import { getForestFile, readForest } from "./state.js";
+
+function writeAnsi(code) {
+  process.stdout.write(code);
+}
+
+function clearScreen() {
+  writeAnsi("\x1b[2J\x1b[H");
+}
+
+function hideCursor() {
+  writeAnsi("\x1b[?25l");
+}
+
+function showCursor() {
+  writeAnsi("\x1b[?25h");
+}
+
+function moveHome() {
+  writeAnsi("\x1b[H");
+}
+
+function renderForest(forest, twinkleSeed = 0) {
+  moveHome();
+  process.stdout.write(renderFrame(forest, process.stdout.columns || 80, { twinkleSeed }));
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function animateNewTree(forest, newTreeId) {
+  const tree = forest.trees.find((entry) => entry.id === newTreeId);
+  if (!tree) {
+    renderForest(forest);
+    return;
+  }
+
+  const originalGrowth = tree.growth;
+  const frames = [0.12, 0.32, 0.6, originalGrowth].filter(
+    (value, index, values) => value <= originalGrowth && values.indexOf(value) === index,
+  );
+
+  for (let index = 0; index < frames.length; index += 1) {
+    tree.growth = frames[index];
+    renderForest(forest, index);
+    await delay(120);
+  }
+
+  tree.growth = originalGrowth;
+  renderForest(forest);
+}
+
+export async function viewer() {
+  const forestFile = getForestFile();
+  let forest = readForest();
+
+  if (!forest || !fs.existsSync(forestFile)) {
+    console.error('No forest found. Run "honeytree init" first.');
+    process.exit(1);
+  }
+
+  hideCursor();
+  clearScreen();
+  renderForest(forest);
+
+  let lastMaxId = forest.trees.reduce((max, tree) => Math.max(max, tree.id), 0);
+
+  const cleanup = () => {
+    showCursor();
+    clearScreen();
+    console.log(
+      `Forest summary: ${forest.trees.length} trees across ${forest.totalPrompts} prompts`,
+    );
+    process.exit(0);
+  };
+
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  process.stdout.on("resize", () => {
+    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);
+      }
+    }, 100);
+  });
+}