honeytree 1.1.6 → 1.2.1

package/src/varieties.js

@@ -0,0 +1,30 @@
+// Canonical tree-variety definitions for the CLI forest.
+// Each variety maps to one or more renderable "species" specs: { type, variant }.
+// `type` indexes SPRITES in sprites.js; `variant: "ancient"` routes through
+// getAncientSprite (the type is then a base placeholder).
+export const VARIETIES = [
+  { key: "standard", threshold: 0,  label: "Standard",       species: [{ type: "birch" }, { type: "willow" }] },
+  { key: "cherry",   threshold: 1,  label: "Cherry Blossom", species: [{ type: "cherry_blossom" }] },
+  { key: "pine",     threshold: 5,  label: "Pine",           species: [{ type: "pine" }] },
+  { key: "oak",      threshold: 10, label: "Oak",            species: [{ type: "oak" }] },
+  { key: "ancient",  threshold: 25, label: "Ancient",        species: [{ type: "oak", variant: "ancient" }] },
+  { key: "mythic",   threshold: 50, label: "Mythic",         species: [{ type: "mythic" }] },
+];
+
+// Build the species pool from the set of unlocked variety keys.
+// `standard` is always included.
+export function unlockedPool(unlockedKeys = []) {
+  const keys = new Set(["standard", ...unlockedKeys]);
+  const pool = [];
+  for (const v of VARIETIES) {
+    if (keys.has(v.key)) pool.push(...v.species);
+  }
+  return pool;
+}
+
+const STANDARD_SPECIES = VARIETIES[0].species;
+
+export function pickSpecies(pool) {
+  const list = Array.isArray(pool) && pool.length > 0 ? pool : STANDARD_SPECIES;
+  return list[Math.floor(Math.random() * list.length)];
+}

package/src/viewer2d.js

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import React from "react";
+import { render } from "ink";
+
+import ForestApp from "./components/ForestApp.js";
+
+export function createForestWatcher(filePath, onChange) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) return null;
+
+    const watcher = fs.watch(filePath, onChange);
+    watcher.on("error", () => {
+      try { watcher.close(); } catch {}
+    });
+    return watcher;
+  } catch {
+    return null;
+  }
+}
+
+export async function viewer() {
+  render(React.createElement(ForestApp));
+}

package/src/markdown.js

@@ -1,77 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-import { readForest } from "./state.js";
-import { renderPlainText, getWiltFactor } from "./renderer.js";
-
-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)`,
-    ``,
-    statParts.join(" · "),
-    ``,
-    "```",
-    art,
-    "```",
-    ``,
-    `${forest.totalPrompts} prompts over ${days} day${days === 1 ? "" : "s"}`,
-    ``,
-    `<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>`,
-    ``,
-  ];
-
-  return lines.join("\n");
-}
-
-export async function generateForestMd() {
-  const forest = readForest();
-  if (!forest) {
-    console.error('No forest found. Run "honeytree init" first.');
-    process.exit(1);
-  }
-
-  const md = buildMarkdown(forest);
-  const outPath = path.resolve("FOREST.md");
-  fs.writeFileSync(outPath, md);
-
-  console.log(`Written to ${outPath}`);
-  console.log("Tip: run `honeytree badge` to generate the badge SVG too.");
-}

package/src/viewer.js

@@ -1,234 +0,0 @@
-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);
-}
-
-function clearScreen() {
-  writeAnsi("\x1b[2J\x1b[H");
-}
-
-function hideCursor() {
-  writeAnsi("\x1b[?25l");
-}
-
-function showCursor() {
-  writeAnsi("\x1b[?25h");
-}
-
-function moveHome() {
-  writeAnsi("\x1b[H");
-}
-
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-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);
-  }
-
-  // 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() {
-    const cols = process.stdout.columns || 80;
-    if (forest.viewerWidth !== cols) {
-      forest.viewerWidth = cols;
-      ignoreNextChange = true;
-      writeForest(forest);
-    }
-  }
-
-  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);
-
-  const cleanup = () => {
-    // Persist viewport position for next session
-    forest.viewportX = viewportX;
-    ignoreNextChange = true;
-    writeForest(forest);
-    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", () => {
-    syncWidth();
-    clearScreen();
-    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;
-
-    if (ignoreNextChange) {
-      ignoreNextChange = false;
-      return;
-    }
-
-    const updated = readForest();
-    if (!updated) return;
-
-    // Only re-render if something actually changed
-    if (updated.totalPrompts === lastTotalPrompts) return;
-
-    const nextMaxId = updated.trees.reduce((max, tree) => Math.max(max, tree.id), 0);
-    forest = updated;
-    lastTotalPrompts = forest.totalPrompts;
-
-    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;
-    } else {
-      renderForest(forest);
-    }
-  }
-
-  // fs.watch can drop events on macOS after atomic renames, so
-  // use it for fast response but also poll as a reliable fallback
-  function startWatcher() {
-    try {
-      const watcher = fs.watch(forestFile, () => {
-        checkForUpdates();
-      });
-      watcher.on("error", () => {});
-      return watcher;
-    } catch {
-      return null;
-    }
-  }
-
-  let watcher = startWatcher();
-
-  // Poll every 800ms as fallback — cheap since it only reads if mtime changed
-  let lastMtime = 0;
-  try {
-    lastMtime = fs.statSync(forestFile).mtimeMs;
-  } catch {}
-
-  setInterval(() => {
-    try {
-      const mtime = fs.statSync(forestFile).mtimeMs;
-      if (mtime !== lastMtime) {
-        lastMtime = mtime;
-        checkForUpdates();
-
-        // Re-establish watcher in case rename killed it
-        if (watcher) {
-          try { watcher.close(); } catch {}
-        }
-        watcher = startWatcher();
-      }
-    } catch {}
-  }, 800);
-}