honeytree 1.1.5 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "honeytree",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "Grow a forest in your terminal every time you use Claude Code",
   "type": "module",
   "bin": {
@@ -33,7 +33,8 @@
   "author": "Varun Nukala",
   "license": "MIT",
   "dependencies": {
-    "chalk": "^5.4.1"
+    "chalk": "^5.4.1",
+    "honeytree": "^1.1.5"
   },
   "engines": {
     "node": ">=18"

package/src/migrate.js

@@ -0,0 +1,47 @@
+import { getVirtualWidth } from "./plant.js";
+
+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;
+}
+
+export function migrateLayout(forest, termWidth) {
+  if (forest.layoutVersion >= 2) return forest;
+
+  const trees = forest.trees;
+  if (trees.length === 0) {
+    forest.layoutVersion = 2;
+    return forest;
+  }
+
+  const virtualWidth = getVirtualWidth(trees.length, termWidth);
+  const margin = 6;
+  const usable = virtualWidth - margin * 2;
+
+  // Sort by current x to preserve left-to-right order
+  const sorted = [...trees].sort((a, b) => a.x - b.x);
+
+  // Spread evenly across usable width with deterministic jitter
+  const gap = trees.length === 1 ? 0 : usable / (trees.length - 1);
+
+  for (let i = 0; i < sorted.length; i++) {
+    const baseX = trees.length === 1
+      ? Math.round(virtualWidth / 2)
+      : Math.round(margin + i * gap);
+    // Deterministic jitter: +/-2 based on tree id
+    const jitter = (hash(sorted[i].id * 7 + 31) % 5) - 2;
+    sorted[i].x = Math.max(margin, Math.min(virtualWidth - margin, baseX + jitter));
+  }
+
+  // Ensure order is preserved after jitter — nudge if needed
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i].x <= sorted[i - 1].x) {
+      sorted[i].x = sorted[i - 1].x + 1;
+    }
+  }
+
+  forest.layoutVersion = 2;
+  return forest;
+}

package/src/plant.js

@@ -1,14 +1,22 @@
 import { getSprite, TREE_TYPES } from "./sprites.js";
 import { createEmptyForest, readForest, writeForest } from "./state.js";
 import { findBadgeFile, writeBadgeSVG } from "./badge.js";
+import { migrateLayout } from "./migrate.js";
 
-const MIN_GAP = 4;
+const MIN_GAP = 6;
 const DEFAULT_WIDTH = 80;
+const TREE_SPACING = 6;
+
+export function getVirtualWidth(treeCount, termWidth) {
+  return Math.max(termWidth, treeCount * TREE_SPACING);
+}
 
 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;
+  const termWidth = forest.viewerWidth && forest.viewerWidth > 40
+    ? forest.viewerWidth
+    : DEFAULT_WIDTH;
+  const treeCount = forest.trees.length + 1;
+  return getVirtualWidth(treeCount, termWidth);
 }
 
 function randomItem(items) {
@@ -64,6 +72,14 @@ export async function plant() {
   const forest = readForest() ?? createEmptyForest();
   const width = getPlantWidth(forest);
 
+  // Migrate old layouts to use virtual width
+  if (!forest.layoutVersion || forest.layoutVersion < 2) {
+    const termWidth = forest.viewerWidth && forest.viewerWidth > 40
+      ? forest.viewerWidth
+      : DEFAULT_WIDTH;
+    migrateLayout(forest, termWidth);
+  }
+
   // Update streak
   const today = new Date().toISOString().slice(0, 10);
   if (forest.lastActiveDate) {

package/src/renderer.js

@@ -1,9 +1,10 @@
 import chalk from "chalk";
 
-import { getSprite, TREE_TYPES } from "./sprites.js";
+import { getSprite, getGroundDetail, TREE_TYPES, GROUND_DETAIL_TYPES } from "./sprites.js";
+import { getVirtualWidth } from "./plant.js";
 
 const SKY_ROWS = 4;
-const TREE_ROWS = 7;
+const TREE_ROWS = 10;
 const GROUND_ROWS = 2;
 const SPACER_ROWS = 1;
 const STATS_ROWS = 1;
@@ -92,6 +93,8 @@ const BIOMES = [
     starDensity: 12,
     starColors: ["#3a3a3a", "#444444"],
     label: "clearing",
+    detailDensity: 0,
+    detailTypes: [],
   },
   { // 10-24: young grove
     ground: ["#22492d", "#18361f"],
@@ -99,6 +102,8 @@ const BIOMES = [
     starDensity: 9,
     starColors: ["#444444", "#5d5d5d"],
     label: "grove",
+    detailDensity: 18,
+    detailTypes: ["rock", "grass"],
   },
   { // 25-49: dense woodland
     ground: ["#1e4a28", "#163a1e"],
@@ -106,6 +111,8 @@ const BIOMES = [
     starDensity: 7,
     starColors: ["#4d4d4d", "#5d5d5d", "#6a6a55"],
     label: "woodland",
+    detailDensity: 12,
+    detailTypes: ["rock", "grass", "mushroom", "bush"],
   },
   { // 50-99: old growth
     ground: ["#1a5230", "#124020"],
@@ -113,6 +120,8 @@ const BIOMES = [
     starDensity: 6,
     starColors: ["#5d5d5d", "#6d6d5a", "#7a7a60"],
     label: "old growth",
+    detailDensity: 8,
+    detailTypes: ["rock", "grass", "mushroom", "bush", "leaf"],
   },
   { // 100+: ancient forest
     ground: ["#165a32", "#0e4822"],
@@ -120,6 +129,8 @@ const BIOMES = [
     starDensity: 5,
     starColors: ["#6d6d5a", "#7a7a60", "#8a8a6a"],
     label: "ancient forest",
+    detailDensity: 5,
+    detailTypes: ["rock", "grass", "mushroom", "bush", "leaf"],
   },
 ];
 
@@ -144,6 +155,11 @@ function hash(seed) {
   return ((value >>> 16) ^ value) >>> 0;
 }
 
+function getTreeYOffset(treeId) {
+  const h = hash(treeId * 13 + 7);
+  return h % 2; // Returns 0 or 1 (only up, never below ground)
+}
+
 function generateStars(width, biome, twinkle = 0) {
   const stars = [];
   for (let x = 0; x < width; x += 1) {
@@ -175,6 +191,41 @@ function compositeSprite(buffer, sprite, centerX, baseY) {
   }
 }
 
+function renderGroundDetails(buffer, biome, virtualWidth, groundStart) {
+  if (biome.detailDensity === 0 || biome.detailTypes.length === 0) return;
+
+  const detailRow = groundStart - 1; // lowest tree row, just above ground
+
+  for (let x = 0; x < virtualWidth; x += 1) {
+    const h = hash(x * 53 + 9973);
+    if (h % biome.detailDensity !== 0) continue;
+
+    // Pick detail type deterministically
+    const detailType = biome.detailTypes[h % biome.detailTypes.length];
+    const sprite = getGroundDetail(detailType);
+
+    // Only place if all cells are currently empty (no tree pixel there)
+    // compositeSprite centers the sprite, so match that logic here
+    const offsetX = x - Math.floor(sprite.width / 2);
+    let blocked = false;
+    for (let rowIndex = 0; rowIndex < sprite.rows.length; rowIndex++) {
+      const targetY = detailRow - rowIndex;
+      if (targetY < 0 || targetY >= buffer.length) { blocked = true; break; }
+      for (let colIndex = 0; colIndex < sprite.rows[rowIndex].length; colIndex++) {
+        const targetX = offsetX + colIndex;
+        if (targetX < 0 || targetX >= virtualWidth) { blocked = true; break; }
+        const [, color] = sprite.rows[rowIndex][colIndex];
+        if (color && buffer[targetY][targetX].color) { blocked = true; break; }
+      }
+      if (blocked) break;
+    }
+    if (blocked) continue;
+
+    // Place the detail sprite (compositeSprite centers at x)
+    compositeSprite(buffer, sprite, x, detailRow);
+  }
+}
+
 function getNextMilestone(treeCount) {
   return MILESTONES.find((value) => treeCount < value) ?? treeCount + 100;
 }
@@ -198,7 +249,7 @@ function buildStreakSegment(forest) {
   return chalk.hex(STREAK_COLOR)(`${streak}-day streak`);
 }
 
-function buildStatsLine(forest, biome) {
+function buildStatsLine(forest, biome, viewportX = 0, virtualWidth = 0, termWidth = 80) {
   const treeCount = forest.trees.length;
   const milestone = getNextMilestone(treeCount);
   const progress = milestone === 0 ? 0 : treeCount / milestone;
@@ -208,6 +259,25 @@ function buildStatsLine(forest, biome) {
     chalk.hex(BAR_FILL)("█".repeat(filledWidth)) +
     chalk.hex(BAR_EMPTY)("░".repeat(barWidth - filledWidth));
 
+  // Viewport minimap — only show when forest is wider than terminal
+  let minimap = "";
+  if (virtualWidth > termWidth) {
+    const mapWidth = 12;
+    const viewFraction = termWidth / virtualWidth;
+    const thumbWidth = Math.max(1, Math.round(viewFraction * mapWidth));
+    const maxOffset = virtualWidth - termWidth;
+    const thumbPos = maxOffset > 0
+      ? Math.round((viewportX / maxOffset) * (mapWidth - thumbWidth))
+      : 0;
+    const mapBar =
+      "─".repeat(thumbPos) +
+      "═".repeat(thumbWidth) +
+      "─".repeat(mapWidth - thumbPos - thumbWidth);
+    minimap = chalk.hex(STATS_TEXT)(" [") +
+      chalk.hex(BAR_FILL)(mapBar) +
+      chalk.hex(STATS_TEXT)("]");
+  }
+
   return (
     chalk.hex(STATS_ACCENT)(" honeytree") +
     chalk.hex(STATS_TEXT)(
@@ -217,23 +287,32 @@ function buildStatsLine(forest, biome) {
     chalk.hex(STATS_TEXT)(" · ") +
     bar +
     chalk.hex(STATS_TEXT)(` next: ${getNextTreeType(treeCount)}`) +
-    chalk.hex("#555555")(` [${biome.label}]`)
+    chalk.hex("#555555")(` [${biome.label}]`) +
+    minimap
   );
 }
 
 export function renderFrame(forest, termWidth = 80, options = {}) {
   const width = Math.max(40, termWidth);
-  const buffer = createBuffer(width);
+  const treeCount = forest.trees.length;
+  const virtualWidth = options.virtualWidth ?? getVirtualWidth(treeCount, width);
+  const viewportX = Math.max(
+    0,
+    Math.min(options.viewportX ?? 0, Math.max(0, virtualWidth - width)),
+  );
+
+  // Build the full virtual-width buffer
+  const buffer = createBuffer(virtualWidth);
   const groundStart = SKY_ROWS + TREE_ROWS;
-  const biome = getBiome(forest.trees.length);
+  const biome = getBiome(treeCount);
   const wilt = getWiltFactor(forest.lastActiveDate);
 
-  for (const star of generateStars(width, biome, options.twinkleSeed ?? 0)) {
+  for (const star of generateStars(virtualWidth, biome, 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) {
+    for (let x = 0; x < virtualWidth; x += 1) {
       buffer[groundStart + rowIndex][x] = {
         char: "█",
         color: biome.ground[rowIndex],
@@ -243,19 +322,23 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
 
   const treeBaseY = groundStart - 1;
   for (const tree of forest.trees) {
-    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY);
+    const yOffset = getTreeYOffset(tree.id);
+    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY - yOffset);
   }
 
-  applyFog(buffer, wilt, width);
+  renderGroundDetails(buffer, biome, virtualWidth, groundStart);
+
+  applyFog(buffer, wilt, virtualWidth);
 
+  // Slice the viewport from the virtual buffer
   const lines = [];
   for (let y = 0; y < SCENE_HEIGHT - SPACER_ROWS - STATS_ROWS - CTA_ROWS; y += 1) {
     let line = "";
-    for (const cell of buffer[y]) {
+    for (let x = viewportX; x < viewportX + width; x += 1) {
+      const cell = buffer[y][x];
       if (!cell.color) {
         line += cell.char;
       } else {
-        // Apply wilting to tree rows and ground (skip sky)
         const color = wilt > 0 && y >= SKY_ROWS ? wiltColor(cell.color, wilt) : cell.color;
         line += chalk.hex(color)(cell.char);
       }
@@ -264,9 +347,9 @@ export function renderFrame(forest, termWidth = 80, options = {}) {
   }
 
   lines.push("");
-  lines.push(buildStatsLine(forest, biome));
+  lines.push(buildStatsLine(forest, biome, viewportX, virtualWidth, width));
   lines.push(
-    chalk.hex("#555555")(" add your forest to your README → ") +
+    chalk.hex("#555555")(" ← → pan  ·  add your forest to your README → ") +
     chalk.hex(STATS_ACCENT)("honeytree badge"),
   );
 
@@ -297,9 +380,12 @@ export function buildScene(forest, width) {
 
   const treeBaseY = groundStart - 1;
   for (const tree of forest.trees) {
-    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY);
+    const yOffset = getTreeYOffset(tree.id);
+    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY - yOffset);
   }
 
+  renderGroundDetails(buffer, biome, w, groundStart);
+
   applyFog(buffer, wilt, w);
 
   if (wilt > 0) {
@@ -333,7 +419,8 @@ export function renderPlainText(forest, width = 60) {
 
   const treeBaseY = groundStart - 1;
   for (const tree of forest.trees) {
-    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY);
+    const yOffset = getTreeYOffset(tree.id);
+    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY - yOffset);
   }
 
   const lines = [];

package/src/sprites.js

@@ -14,6 +14,19 @@ const COLORS = {
   cherryBloom: "#f0b7cf",
 };
 
+const DETAIL_COLORS = {
+  mushroom: "#c4a882",
+  mushroomCap: "#9e4a3a",
+  rock: "#6b6b6b",
+  rockLight: "#8a8a8a",
+  grass: "#4a7a3a",
+  grassLight: "#6ba85a",
+  leaf: "#8a6a3a",
+  leafDark: "#6a4a2a",
+  bush: "#3a6a2a",
+  bushLight: "#5a8a4a",
+};
+
 function parse(template, palette) {
   const lines = template.trim().split("\n");
   const width = Math.max(...lines.map((line) => line.length));
@@ -229,6 +242,50 @@ pPPpPPPp
   },
 };
 
+const GROUND_DETAILS = {
+  mushroom: parse(
+    `
+rr
+ t
+`,
+    { r: DETAIL_COLORS.mushroomCap, t: DETAIL_COLORS.mushroom },
+  ),
+  rock: parse(
+    `
+rR
+`,
+    { r: DETAIL_COLORS.rock, R: DETAIL_COLORS.rockLight },
+  ),
+  grass: parse(
+    `
+gG
+`,
+    { g: DETAIL_COLORS.grass, G: DETAIL_COLORS.grassLight },
+  ),
+  leaf: parse(
+    `
+lL
+`,
+    { l: DETAIL_COLORS.leaf, L: DETAIL_COLORS.leafDark },
+  ),
+  bush: parse(
+    `
+bB
+`,
+    { b: DETAIL_COLORS.bush, B: DETAIL_COLORS.bushLight },
+  ),
+};
+
+export const GROUND_DETAIL_TYPES = Object.keys(GROUND_DETAILS);
+
+export function getGroundDetail(type) {
+  const detail = GROUND_DETAILS[type];
+  if (!detail) {
+    throw new Error(`Unknown ground detail type: ${type}`);
+  }
+  return detail;
+}
+
 function getGrowthStage(growth) {
   if (growth < 0.2) return "seed";
   if (growth < 0.5) return "sapling";

package/src/viewer.js

@@ -2,6 +2,8 @@ import fs from "node:fs";
 
 import { renderFrame } from "./renderer.js";
 import { getForestFile, readForest, writeForest } from "./state.js";
+import { migrateLayout } from "./migrate.js";
+import { getVirtualWidth } from "./plant.js";
 
 function writeAnsi(code) {
   process.stdout.write(code);
@@ -23,37 +25,10 @@ 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();
@@ -63,6 +38,13 @@ export async function viewer() {
     process.exit(1);
   }
 
+  // Migrate old layouts on first view
+  if (forest && (!forest.layoutVersion || forest.layoutVersion < 2)) {
+    const termWidth = process.stdout.columns || 80;
+    migrateLayout(forest, termWidth);
+    // Will be written to disk by syncWidth below
+  }
+
   // Save terminal width so plant knows how wide to spread trees
   let ignoreNextChange = false;
   function syncWidth() {
@@ -74,16 +56,65 @@ export async function viewer() {
     }
   }
 
+  let lastMaxId = forest.trees.reduce((max, tree) => Math.max(max, tree.id), 0);
+  let lastTotalPrompts = forest.totalPrompts;
+  let animating = false;
+
+  let viewportX = forest.viewportX || 0;
+  const PAN_STEP = 4;
+
+  function getViewportWidth() {
+    return process.stdout.columns || 80;
+  }
+
+  function clampViewport(x) {
+    const vw = getVirtualWidth(forest.trees.length, getViewportWidth());
+    return Math.max(0, Math.min(x, Math.max(0, vw - getViewportWidth())));
+  }
+
+  function renderForest(forest, twinkleSeed = 0) {
+    clearScreen();
+    const termWidth = process.stdout.columns || 80;
+    const vw = getVirtualWidth(forest.trees.length, termWidth);
+    process.stdout.write(renderFrame(forest, termWidth, {
+      twinkleSeed,
+      viewportX,
+      virtualWidth: vw,
+    }));
+  }
+
+  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);
+  }
+
   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 = () => {
+    // Persist viewport position for next session
+    forest.viewportX = viewportX;
+    ignoreNextChange = true;
+    writeForest(forest);
     showCursor();
     clearScreen();
     console.log(
@@ -100,6 +131,34 @@ export async function viewer() {
     renderForest(forest);
   });
 
+  // Enable raw mode for keypress handling
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (data) => {
+      const key = data.toString();
+      // Ctrl+C or q to quit
+      if (key === "\x03" || key === "q") {
+        cleanup();
+        return;
+      }
+      // Left arrow: \x1b[D
+      if (key === "\x1b[D") {
+        viewportX = clampViewport(viewportX - PAN_STEP);
+        forest.viewportX = viewportX;
+        renderForest(forest);
+        return;
+      }
+      // Right arrow: \x1b[C
+      if (key === "\x1b[C") {
+        viewportX = clampViewport(viewportX + PAN_STEP);
+        forest.viewportX = viewportX;
+        renderForest(forest);
+        return;
+      }
+    });
+  }
+
   // Check for changes — used by both fs.watch and polling fallback
   async function checkForUpdates() {
     if (animating) return;
@@ -121,6 +180,12 @@ export async function viewer() {
 
     if (nextMaxId > lastMaxId) {
       lastMaxId = nextMaxId;
+      // Center viewport on the new tree
+      const newTree = forest.trees.find((t) => t.id === nextMaxId);
+      if (newTree) {
+        const termWidth = getViewportWidth();
+        viewportX = clampViewport(newTree.x - Math.floor(termWidth / 2));
+      }
       animating = true;
       await animateNewTree(forest, nextMaxId);
       animating = false;