honeytree 1.0.5 → 1.0.7

package/src/core/sprites.js

@@ -0,0 +1,388 @@
+const BLOCK = "█";
+
+export const TREE_SPECIES = [
+  "sapling",
+  "birch",
+  "oak",
+  "cherry",
+  "pine",
+  "willow",
+  "ancient_oak",
+];
+
+export const ANIMAL_TYPES = ["butterfly", "rabbit", "fox", "deer", "owl"];
+
+export const LLAMA_POSES = ["walking", "sitting", "happy"];
+
+export const GROUND_ELEMENT_TYPES = ["flower", "mushroom", "rock", "tall_grass"];
+
+function parseSprite(template, legend) {
+  const lines = template
+    .trim()
+    .split("\n")
+    .map((line) => line.replace(/\r/g, ""));
+  const width = Math.max(...lines.map((line) => line.length));
+  const rows = lines
+    .map((line) => line.padEnd(width, " "))
+    .map((line) =>
+      Array.from(line, (token) => {
+        if (token === " ") {
+          return null;
+        }
+        return legend[token] ?? null;
+      }),
+    )
+    .reverse();
+
+  return {
+    rows,
+    width,
+    height: rows.length,
+  };
+}
+
+export function materializeSprite(sprite, palette, char = BLOCK) {
+  return {
+    width: sprite.width,
+    height: sprite.height,
+    rows: sprite.rows.map((row) =>
+      row.map((token) => {
+        if (!token) {
+          return [" ", null];
+        }
+        return [char, palette[token] ?? token];
+      }),
+    ),
+  };
+}
+
+export function getTreeSpeciesForCommit(totalCommits) {
+  if (totalCommits <= 5) return "sapling";
+  if (totalCommits <= 15) return "birch";
+  if (totalCommits <= 30) return "oak";
+  if (totalCommits <= 50) return "cherry";
+  if (totalCommits <= 75) return "pine";
+  if (totalCommits <= 100) return "willow";
+  return "ancient_oak";
+}
+
+export function getGroundElementType(totalFileSaves) {
+  const tier = Math.max(0, Math.floor(totalFileSaves / 50) - 1);
+  return GROUND_ELEMENT_TYPES[tier % GROUND_ELEMENT_TYPES.length];
+}
+
+export function getAnimalTypeForMinutes(totalMinutesCoded) {
+  if (totalMinutesCoded >= 480) return "owl";
+  if (totalMinutesCoded >= 240) return "deer";
+  if (totalMinutesCoded >= 120) return "fox";
+  if (totalMinutesCoded >= 60) return "rabbit";
+  return "butterfly";
+}
+
+const TREE_SPRITES = {
+  sapling: parseSprite(
+    `
+  l
+ lL
+  t
+`,
+    {
+      l: "leaf",
+      L: "leafLight",
+      t: "trunk",
+    },
+  ),
+  birch: parseSprite(
+    `
+   ll
+  lLL
+ llLLl
+   bb
+   bB
+`,
+    {
+      l: "leaf",
+      L: "leafLight",
+      b: "birchBark",
+      B: "birchShadow",
+    },
+  ),
+  oak: parseSprite(
+    `
+    dd
+  dllll
+ dllLLlld
+  llllll
+    tt
+   tTT
+`,
+    {
+      d: "leafDark",
+      l: "leaf",
+      L: "leafLight",
+      t: "trunk",
+      T: "trunkLight",
+    },
+  ),
+  cherry: parseSprite(
+    `
+    pp
+  pPPPP
+ pPPpPPP
+  PPPPP
+    tt
+   tTT
+`,
+    {
+      p: "petal",
+      P: "petalLight",
+      t: "trunk",
+      T: "trunkLight",
+    },
+  ),
+  pine: parseSprite(
+    `
+     p
+    pPp
+   pPPPp
+  pPPPPPp
+   PPPPP
+    tT
+    tT
+`,
+    {
+      p: "pineDark",
+      P: "pine",
+      t: "trunkDark",
+      T: "trunk",
+    },
+  ),
+  willow: parseSprite(
+    `
+    llll
+  llLLLLll
+ llLllllLll
+ ll      ll
+  ll    ll
+    tTT
+    tTT
+`,
+    {
+      l: "leaf",
+      L: "leafLight",
+      t: "trunk",
+      T: "trunkLight",
+    },
+  ),
+  ancient_oak: parseSprite(
+    `
+      dd
+   ddllllld
+  dllLLLllld
+ ddllLLLllld
+   llllllll
+     mmm
+    tTTT
+   ttTTtt
+`,
+    {
+      d: "leafDark",
+      l: "leaf",
+      L: "leafLight",
+      m: "moss",
+      t: "trunkDark",
+      T: "trunk",
+    },
+  ),
+};
+
+const ANIMAL_SPRITES = {
+  butterfly: parseSprite(
+    `
+w w
+ W
+`,
+    {
+      w: "wing",
+      W: "wingLight",
+    },
+  ),
+  rabbit: parseSprite(
+    `
+ ee
+rrre
+ rr
+`,
+    {
+      r: "rabbit",
+      e: "rabbitLight",
+    },
+  ),
+  fox: parseSprite(
+    `
+ ff
+ffff
+fllf
+`,
+    {
+      f: "fox",
+      l: "foxLight",
+    },
+  ),
+  deer: parseSprite(
+    `
+ aa
+dddd
+d dd
+`,
+    {
+      a: "deerLight",
+      d: "deer",
+    },
+  ),
+  owl: parseSprite(
+    `
+ oo
+OooO
+ tt
+`,
+    {
+      o: "owl",
+      O: "owlLight",
+      t: "trunkDark",
+    },
+  ),
+};
+
+const LLAMA_SPRITES = {
+  walking: parseSprite(
+    `
+  ee
+ lllN
+llll
+l  l
+`,
+    {
+      e: "llamaLight",
+      l: "llama",
+      N: "llamaNose",
+    },
+  ),
+  sitting: parseSprite(
+    `
+  ee
+ lllN
+ lll
+  ll
+`,
+    {
+      e: "llamaLight",
+      l: "llama",
+      N: "llamaNose",
+    },
+  ),
+  happy: parseSprite(
+    `
+  ee
+ lllN
+llll
+l  l
+`,
+    {
+      e: "llamaLight",
+      l: "llama",
+      N: "llamaNose",
+    },
+  ),
+};
+
+const GROUND_SPRITES = {
+  flower: parseSprite(
+    `
+ c
+FfF
+ g
+`,
+    {
+      c: "flowerCenter",
+      F: "flower",
+      f: "flowerLight",
+      g: "grassLight",
+    },
+  ),
+  mushroom: parseSprite(
+    `
+MMM
+ s
+`,
+    {
+      M: "mushroomCap",
+      s: "mushroomStem",
+    },
+  ),
+  rock: parseSprite(
+    `
+ rr
+rrrr
+`,
+    {
+      r: "stone",
+    },
+  ),
+  tall_grass: parseSprite(
+    `
+ gg
+ggg
+`,
+    {
+      g: "grass",
+    },
+  ),
+};
+
+export function getTreeSprite(species) {
+  const sprite = TREE_SPRITES[species];
+  if (!sprite) {
+    throw new Error(`Unknown tree species: ${species}`);
+  }
+  return sprite;
+}
+
+export function getAnimalSprite(type) {
+  const sprite = ANIMAL_SPRITES[type];
+  if (!sprite) {
+    throw new Error(`Unknown animal type: ${type}`);
+  }
+  return sprite;
+}
+
+export function getGroundElementSprite(type) {
+  const sprite = GROUND_SPRITES[type];
+  if (!sprite) {
+    throw new Error(`Unknown ground element type: ${type}`);
+  }
+  return sprite;
+}
+
+export function getLlamaSprite(pose = "walking") {
+  const sprite = LLAMA_SPRITES[pose];
+  if (!sprite) {
+    throw new Error(`Unknown llama pose: ${pose}`);
+  }
+  return sprite;
+}
+
+export function getRandomGroundElement() {
+  return GROUND_ELEMENT_TYPES[Math.floor(Math.random() * GROUND_ELEMENT_TYPES.length)];
+}
+
+export function getSpriteWidth(kind, type) {
+  if (kind === "tree") {
+    return getTreeSprite(type).width;
+  }
+  if (kind === "animal") {
+    return getAnimalSprite(type).width;
+  }
+  return getGroundElementSprite(type).width;
+}
+

package/src/core/state.js

@@ -0,0 +1,173 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const STATE_DIR_NAME = ".honeytree";
+const STATE_FILE_NAME = "state.json";
+const LEGACY_DIR_NAME = ".honeydew";
+const LEGACY_FILE_NAME = "forest.json";
+
+function todayString(now = new Date()) {
+  return now.toISOString().slice(0, 10);
+}
+
+function resolveStateDir() {
+  return process.env.HONEYTREE_DIR || path.join(os.homedir(), STATE_DIR_NAME);
+}
+
+function resolveLegacyDir() {
+  return process.env.HONEYDEW_DIR || path.join(os.homedir(), LEGACY_DIR_NAME);
+}
+
+export function getStateDir() {
+  return resolveStateDir();
+}
+
+export function getStateFile() {
+  return path.join(resolveStateDir(), STATE_FILE_NAME);
+}
+
+export function getLegacyForestFile() {
+  return path.join(resolveLegacyDir(), LEGACY_FILE_NAME);
+}
+
+export function createEmptyState(now = new Date()) {
+  return {
+    total_commits: 0,
+    total_file_saves: 0,
+    total_minutes_coded: 0,
+    current_streak: 0,
+    last_active_date: todayString(now),
+    last_commit_hash: "",
+    trees: [],
+    animals: [],
+    ground_elements: [],
+  };
+}
+
+function normalizeTree(tree) {
+  return {
+    species: tree?.species ?? tree?.type ?? "sapling",
+    planted_at: tree?.planted_at ?? tree?.plantedAt ?? new Date().toISOString(),
+    x_position: Number.isFinite(tree?.x_position) ? tree.x_position : tree?.x ?? 12,
+  };
+}
+
+function normalizeAnimal(animal) {
+  return {
+    type: animal?.type ?? "butterfly",
+    x_position: Number.isFinite(animal?.x_position) ? animal.x_position : animal?.x ?? 10,
+    direction: animal?.direction === "left" ? "left" : "right",
+  };
+}
+
+function normalizeGroundElement(element) {
+  return {
+    type: element?.type ?? "flower",
+    x_position: Number.isFinite(element?.x_position) ? element.x_position : element?.x ?? 8,
+  };
+}
+
+export function normalizeState(input = {}) {
+  const base = createEmptyState();
+  return {
+    total_commits: Number.isFinite(input.total_commits)
+      ? input.total_commits
+      : input.totalPrompts ?? base.total_commits,
+    total_file_saves: Number.isFinite(input.total_file_saves) ? input.total_file_saves : 0,
+    total_minutes_coded: Number.isFinite(input.total_minutes_coded) ? input.total_minutes_coded : 0,
+    current_streak: Number.isFinite(input.current_streak)
+      ? input.current_streak
+      : input.streak ?? base.current_streak,
+    last_active_date:
+      typeof input.last_active_date === "string"
+        ? input.last_active_date
+        : input.lastActiveDate ?? base.last_active_date,
+    last_commit_hash: typeof input.last_commit_hash === "string" ? input.last_commit_hash : "",
+    trees: Array.isArray(input.trees) ? input.trees.map(normalizeTree) : [],
+    animals: Array.isArray(input.animals) ? input.animals.map(normalizeAnimal) : [],
+    ground_elements: Array.isArray(input.ground_elements)
+      ? input.ground_elements.map(normalizeGroundElement)
+      : [],
+  };
+}
+
+export function migrateOldForest(oldForest = {}) {
+  const migrated = createEmptyState();
+  migrated.total_commits = oldForest.totalPrompts ?? oldForest.trees?.length ?? 0;
+  migrated.current_streak = oldForest.streak ?? 0;
+  migrated.last_active_date = oldForest.lastActiveDate ?? todayString();
+  migrated.trees = Array.isArray(oldForest.trees) ? oldForest.trees.map(normalizeTree) : [];
+  return migrated;
+}
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function backupCorruptState(filePath) {
+  const dir = path.dirname(filePath);
+  const backupFile = path.join(
+    dir,
+    `${path.basename(filePath, ".json")}.bak.${Date.now()}.json`,
+  );
+  try {
+    fs.renameSync(filePath, backupFile);
+  } catch {}
+}
+
+export function readState() {
+  const stateFile = getStateFile();
+  try {
+    if (fs.existsSync(stateFile)) {
+      return normalizeState(readJson(stateFile));
+    }
+  } catch {
+    backupCorruptState(stateFile);
+    return createEmptyState();
+  }
+
+  const legacyFile = getLegacyForestFile();
+  try {
+    if (fs.existsSync(legacyFile)) {
+      const migrated = migrateOldForest(readJson(legacyFile));
+      writeState(migrated);
+      return migrated;
+    }
+  } catch {}
+
+  return null;
+}
+
+export function writeState(state) {
+  const directory = getStateDir();
+  const stateFile = getStateFile();
+  const tmpFile = path.join(
+    directory,
+    `state.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`,
+  );
+  fs.mkdirSync(directory, { recursive: true });
+  fs.writeFileSync(tmpFile, JSON.stringify(normalizeState(state), null, 2));
+  fs.renameSync(tmpFile, stateFile);
+}
+
+export function ensureState() {
+  const state = readState();
+  if (state) {
+    return state;
+  }
+  const fresh = createEmptyState();
+  writeState(fresh);
+  return fresh;
+}
+
+export function updateState(mutator) {
+  const current = ensureState();
+  const draft = globalThis.structuredClone ? structuredClone(current) : JSON.parse(JSON.stringify(current));
+  const next = mutator(draft) ?? draft;
+  const normalized = normalizeState(next);
+  writeState(normalized);
+  return normalized;
+}
+

package/src/markdown.js

@@ -1,58 +1,28 @@
 import fs from "node:fs";
 import path from "node:path";
 
-import { readForest } from "./state.js";
-import { renderPlainText, getWiltFactor } from "./renderer.js";
+import { getEnvironmentSnapshot } from "./core/environment.js";
+import { readState } from "./core/state.js";
+import { renderTerminalFrame } from "./renderers/terminal.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}**`);
+export function buildMarkdown(state) {
+  const environment = getEnvironmentSnapshot(new Date(), state.current_streak);
+  const art = renderTerminalFrame(state, 80, 0, { color: false });
 
   const lines = [
     `<div align="center">`,
     ``,
     `[![honeytree](./honeytree-badge.svg)](https://github.com/Varun2009178/honeytree)`,
     ``,
-    statParts.join(" · "),
+    `**${state.trees.length} trees** · **${state.animals.length} animals** · **${state.current_streak} day streak** · **${environment.season.label} ${environment.weather.label}**`,
     ``,
     "```",
     art,
     "```",
     ``,
-    `${forest.totalPrompts} prompts over ${days} day${days === 1 ? "" : "s"}`,
+    `${state.total_commits} commits · ${state.total_file_saves} saves · ${state.total_minutes_coded} active minutes`,
     ``,
-    `<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>`,
+    `<sub>Grown with <a href="https://github.com/Varun2009178/honeytree">honeytree</a> — a living pixel forest that grows while you code</sub>`,
     ``,
     `</div>`,
     ``,
@@ -62,16 +32,15 @@ function buildMarkdown(forest) {
 }
 
 export async function generateForestMd() {
-  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 md = buildMarkdown(forest);
+  const md = buildMarkdown(state);
   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.");
 }