honeytree 1.1.4 → 1.1.6

package/src/plant.js

@@ -0,0 +1,124 @@
+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 = 6;
+const DEFAULT_WIDTH = 80;
+const TREE_SPACING = 6;
+
+export function getVirtualWidth(treeCount, termWidth) {
+  return Math.max(termWidth, treeCount * TREE_SPACING);
+}
+
+function getPlantWidth(forest) {
+  const termWidth = forest.viewerWidth && forest.viewerWidth > 40
+    ? forest.viewerWidth
+    : DEFAULT_WIDTH;
+  const treeCount = forest.trees.length + 1;
+  return getVirtualWidth(treeCount, termWidth);
+}
+
+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, width) {
+  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, 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, 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);
+}
+
+function daysBetween(dateA, dateB) {
+  const a = new Date(dateA + "T00:00:00");
+  const b = new Date(dateB + "T00:00:00");
+  return Math.round(Math.abs(b - a) / (24 * 60 * 60 * 1000));
+}
+
+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) {
+    const gap = daysBetween(forest.lastActiveDate, today);
+    if (gap === 0) {
+      // Same day — streak stays (ensure at least 1)
+      forest.streak = Math.max(forest.streak || 0, 1);
+    } else if (gap === 1) {
+      forest.streak = (forest.streak || 1) + 1;
+    } else {
+      forest.streak = 1;
+    }
+  } else {
+    forest.streak = 1;
+  }
+  forest.lastActiveDate = today;
+
+  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, width),
+    plantedAt: new Date().toISOString(),
+  });
+  forest.totalPrompts += 1;
+
+  writeForest(forest);
+
+  // Auto-refresh badge if one exists in the repo
+  try {
+    const badgePath = findBadgeFile();
+    if (badgePath) writeBadgeSVG(forest, badgePath);
+  } catch {}
+}

package/src/renderer.js

@@ -0,0 +1,436 @@
+import chalk from "chalk";
+
+import { getSprite, getGroundDetail, TREE_TYPES, GROUND_DETAIL_TYPES } from "./sprites.js";
+import { getVirtualWidth } from "./plant.js";
+
+const SKY_ROWS = 4;
+const TREE_ROWS = 10;
+const GROUND_ROWS = 2;
+const SPACER_ROWS = 1;
+const STATS_ROWS = 1;
+const CTA_ROWS = 1;
+
+export const SCENE_HEIGHT =
+  SKY_ROWS + TREE_ROWS + GROUND_ROWS + SPACER_ROWS + STATS_ROWS + CTA_ROWS;
+
+const STATS_ACCENT = "#f5a50b";
+const STATS_TEXT = "#8e8a84";
+const STATS_WARN = "#c4653a";
+const STREAK_COLOR = "#e8a33a";
+const BAR_FILL = "#6cb95e";
+const BAR_EMPTY = "#3d3d3d";
+const MILESTONES = [10, 25, 50, 100, 250, 500, 1000];
+
+// Wilting — lerp toward dry brown when idle
+const WILT_TARGET = { r: 0x8a, g: 0x6a, b: 0x4a };
+
+function parseHex(hex) {
+  const h = hex.startsWith("#") ? hex.slice(1) : hex;
+  return {
+    r: parseInt(h.slice(0, 2), 16),
+    g: parseInt(h.slice(2, 4), 16),
+    b: parseInt(h.slice(4, 6), 16),
+  };
+}
+
+function toHex({ r, g, b }) {
+  const c = (v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
+  return `#${c(r)}${c(g)}${c(b)}`;
+}
+
+function wiltColor(hex, factor) {
+  if (factor <= 0) return hex;
+  const c = parseHex(hex);
+  return toHex({
+    r: c.r + (WILT_TARGET.r - c.r) * factor,
+    g: c.g + (WILT_TARGET.g - c.g) * factor,
+    b: c.b + (WILT_TARGET.b - c.b) * factor,
+  });
+}
+
+export function getWiltFactor(lastActiveDate) {
+  if (!lastActiveDate) return 0;
+  const today = new Date().toISOString().slice(0, 10);
+  const a = new Date(lastActiveDate + "T00:00:00");
+  const b = new Date(today + "T00:00:00");
+  const days = Math.round((b - a) / (24 * 60 * 60 * 1000));
+  if (days <= 0) return 0;
+  if (days === 1) return 0.25;
+  if (days === 2) return 0.45;
+  if (days === 3) return 0.65;
+  return Math.min(0.85, 0.65 + (days - 3) * 0.05);
+}
+
+// Fog — procedural haze that thickens with inactivity
+const FOG_CHARS = ["░", "░", "▒"];
+const FOG_COLOR_UPPER = "#9a9a9a";
+const FOG_COLOR_LOWER = "#6a6a6a";
+
+function applyFog(buffer, wilt, width) {
+  if (wilt <= 0) return;
+  // Higher wilt → lower threshold → more fog
+  const threshold = Math.max(3, Math.round(18 * (1 - wilt)));
+  const fogStart = SKY_ROWS - 2; // creep into lower sky
+  const fogEnd = SKY_ROWS + TREE_ROWS + GROUND_ROWS;
+
+  for (let y = Math.max(0, fogStart); y < fogEnd; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      const h = hash(x * 31 + y * 97 + 12345);
+      if (h % threshold !== 0) continue;
+      const fogChar = FOG_CHARS[h % FOG_CHARS.length];
+      const blend = (y - fogStart) / (fogEnd - fogStart);
+      const fogColor = blend > 0.5 ? FOG_COLOR_LOWER : FOG_COLOR_UPPER;
+      buffer[y][x] = { char: fogChar, color: fogColor };
+    }
+  }
+}
+
+// Biomes evolve as the forest grows — never resets, only gets richer
+const BIOMES = [
+  { // 0-9: sparse clearing
+    ground: ["#2a3a28", "#1e2d1c"],
+    starGlyphs: ["·", ".", " ", " "],
+    starDensity: 12,
+    starColors: ["#3a3a3a", "#444444"],
+    label: "clearing",
+    detailDensity: 0,
+    detailTypes: [],
+  },
+  { // 10-24: young grove
+    ground: ["#22492d", "#18361f"],
+    starGlyphs: ["·", "·", "✦", "."],
+    starDensity: 9,
+    starColors: ["#444444", "#5d5d5d"],
+    label: "grove",
+    detailDensity: 18,
+    detailTypes: ["rock", "grass"],
+  },
+  { // 25-49: dense woodland
+    ground: ["#1e4a28", "#163a1e"],
+    starGlyphs: ["·", "✦", "✧", "·", "."],
+    starDensity: 7,
+    starColors: ["#4d4d4d", "#5d5d5d", "#6a6a55"],
+    label: "woodland",
+    detailDensity: 12,
+    detailTypes: ["rock", "grass", "mushroom", "bush"],
+  },
+  { // 50-99: old growth
+    ground: ["#1a5230", "#124020"],
+    starGlyphs: ["✦", "✧", "·", "·", "✦", "."],
+    starDensity: 6,
+    starColors: ["#5d5d5d", "#6d6d5a", "#7a7a60"],
+    label: "old growth",
+    detailDensity: 8,
+    detailTypes: ["rock", "grass", "mushroom", "bush", "leaf"],
+  },
+  { // 100+: ancient forest
+    ground: ["#165a32", "#0e4822"],
+    starGlyphs: ["✦", "✧", "·", "✦", "⋆", "."],
+    starDensity: 5,
+    starColors: ["#6d6d5a", "#7a7a60", "#8a8a6a"],
+    label: "ancient forest",
+    detailDensity: 5,
+    detailTypes: ["rock", "grass", "mushroom", "bush", "leaf"],
+  },
+];
+
+function getBiome(treeCount) {
+  if (treeCount < 10) return BIOMES[0];
+  if (treeCount < 25) return BIOMES[1];
+  if (treeCount < 50) return BIOMES[2];
+  if (treeCount < 100) return BIOMES[3];
+  return BIOMES[4];
+}
+
+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 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) {
+    const seeded = hash(x + width * 17 + twinkle * 101);
+    if (seeded % biome.starDensity !== 0) continue;
+    stars.push({
+      x,
+      y: seeded % SKY_ROWS,
+      char: biome.starGlyphs[seeded % biome.starGlyphs.length],
+      color: biome.starColors[seeded % biome.starColors.length],
+    });
+  }
+  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 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;
+}
+
+function getNextTreeType(treeCount) {
+  return TREE_TYPES[treeCount % TREE_TYPES.length];
+}
+
+function buildStreakSegment(forest) {
+  const wilt = getWiltFactor(forest.lastActiveDate);
+  const streak = forest.streak || 0;
+
+  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));
+    return chalk.hex(STATS_WARN)(`wilting (${idle}d idle)`);
+  }
+
+  if (streak <= 0) return chalk.hex(STATS_TEXT)("no streak");
+  return chalk.hex(STREAK_COLOR)(`${streak}-day streak`);
+}
+
+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;
+  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));
+
+  // 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)(
+      ` · ${treeCount} tree${treeCount === 1 ? "" : "s"} · `,
+    ) +
+    buildStreakSegment(forest) +
+    chalk.hex(STATS_TEXT)(" · ") +
+    bar +
+    chalk.hex(STATS_TEXT)(` next: ${getNextTreeType(treeCount)}`) +
+    chalk.hex("#555555")(` [${biome.label}]`) +
+    minimap
+  );
+}
+
+export function renderFrame(forest, termWidth = 80, options = {}) {
+  const width = Math.max(40, termWidth);
+  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(treeCount);
+  const wilt = getWiltFactor(forest.lastActiveDate);
+
+  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 < virtualWidth; x += 1) {
+      buffer[groundStart + rowIndex][x] = {
+        char: "█",
+        color: biome.ground[rowIndex],
+      };
+    }
+  }
+
+  const treeBaseY = groundStart - 1;
+  for (const tree of forest.trees) {
+    const yOffset = getTreeYOffset(tree.id);
+    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY - yOffset);
+  }
+
+  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 (let x = viewportX; x < viewportX + width; x += 1) {
+      const cell = buffer[y][x];
+      if (!cell.color) {
+        line += cell.char;
+      } else {
+        const color = wilt > 0 && y >= SKY_ROWS ? wiltColor(cell.color, wilt) : cell.color;
+        line += chalk.hex(color)(cell.char);
+      }
+    }
+    lines.push(line);
+  }
+
+  lines.push("");
+  lines.push(buildStatsLine(forest, biome, viewportX, virtualWidth, width));
+  lines.push(
+    chalk.hex("#555555")(" ← → pan  ·  add your forest to your README → ") +
+    chalk.hex(STATS_ACCENT)("honeytree badge"),
+  );
+
+  return lines.join("\n");
+}
+
+export function buildScene(forest, width) {
+  const w = Math.max(40, width);
+  const sceneRows = SKY_ROWS + TREE_ROWS + GROUND_ROWS;
+  const buffer = Array.from({ length: sceneRows }, () =>
+    Array.from({ length: w }, () => ({ char: " ", color: null })),
+  );
+  const groundStart = SKY_ROWS + TREE_ROWS;
+  const biome = getBiome(forest.trees.length);
+  const wilt = getWiltFactor(forest.lastActiveDate);
+
+  for (const star of generateStars(w, biome, 0)) {
+    if (star.y < sceneRows) {
+      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 < w; x += 1) {
+      buffer[groundStart + rowIndex][x] = { char: "█", color: biome.ground[rowIndex] };
+    }
+  }
+
+  const treeBaseY = groundStart - 1;
+  for (const tree of forest.trees) {
+    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) {
+    for (let y = SKY_ROWS; y < sceneRows; y += 1) {
+      for (let x = 0; x < w; x += 1) {
+        if (buffer[y][x].color) {
+          buffer[y][x].color = wiltColor(buffer[y][x].color, wilt);
+        }
+      }
+    }
+  }
+
+  return { buffer, biome, sceneRows };
+}
+
+export function renderPlainText(forest, width = 60) {
+  const w = Math.max(40, Math.min(width, 80));
+  const buffer = createBuffer(w);
+  const groundStart = SKY_ROWS + TREE_ROWS;
+  const biome = getBiome(forest.trees.length);
+
+  for (const star of generateStars(w, biome, 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 < w; x += 1) {
+      buffer[groundStart + rowIndex][x] = { char: "█", color: "#333" };
+    }
+  }
+
+  const treeBaseY = groundStart - 1;
+  for (const tree of forest.trees) {
+    const yOffset = getTreeYOffset(tree.id);
+    compositeSprite(buffer, getSprite(tree.type, tree.growth), tree.x, treeBaseY - yOffset);
+  }
+
+  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]) {
+      line += cell.char;
+    }
+    lines.push(line.trimEnd());
+  }
+
+  return lines.join("\n");
+}