honeytree 1.0.5 → 1.0.7

package/src/renderers/terminal.js

@@ -0,0 +1,225 @@
+import chalk from "chalk";
+
+import { getDynamicScene } from "../core/animation.js";
+import { getEnvironmentSnapshot } from "../core/environment.js";
+import {
+  getAnimalSprite,
+  getGroundElementSprite,
+  getLlamaSprite,
+  getTreeSprite,
+  materializeSprite,
+} from "../core/sprites.js";
+
+const SKY_ROWS = 4;
+const FOREST_ROWS = 8;
+const GROUND_ROWS = 1;
+const ART_ROWS = SKY_ROWS + FOREST_ROWS + GROUND_ROWS;
+const STATS_ROWS = 1;
+
+export const SCENE_HEIGHT = ART_ROWS + STATS_ROWS;
+
+function createBuffer(width) {
+  return Array.from({ length: ART_ROWS }, () =>
+    Array.from({ length: width }, () => ({ char: " ", color: null })),
+  );
+}
+
+function paint(buffer, x, y, char, color) {
+  if (y < 0 || y >= buffer.length) return;
+  if (x < 0 || x >= buffer[0].length) return;
+  buffer[y][x] = { char, color };
+}
+
+function compositeSprite(buffer, sprite, centerX, baseY, palette) {
+  const cells = materializeSprite(sprite, palette);
+  const offsetX = Math.round(centerX) - Math.floor(cells.width / 2);
+  for (let rowIndex = 0; rowIndex < cells.rows.length; rowIndex += 1) {
+    const row = cells.rows[rowIndex];
+    const y = baseY - rowIndex;
+    for (let columnIndex = 0; columnIndex < row.length; columnIndex += 1) {
+      const [char, color] = row[columnIndex];
+      if (!color) continue;
+      paint(buffer, offsetX + columnIndex, y, char, color);
+    }
+  }
+}
+
+function colorize(text, color, enabled) {
+  if (!enabled || !color) {
+    return text;
+  }
+  return chalk.hex(color)(text);
+}
+
+function drawSky(buffer, width, environment, tick) {
+  if (environment.sky.name === "night") {
+    const stars = getDynamicScene({ animals: [] }, width, tick, environment).stars;
+    for (const star of stars) {
+      paint(buffer, star.x, star.y, star.twinkle > 0.5 ? "✦" : "·", environment.sky.haze);
+    }
+  }
+
+  const clouds = getDynamicScene({ animals: [] }, width, tick, environment).clouds;
+  for (const cloud of clouds) {
+    const glyph = environment.sky.name === "night" ? "░" : "▓";
+    for (let offset = 0; offset < cloud.length; offset += 1) {
+      paint(buffer, cloud.x + offset, cloud.y, glyph, environment.sky.haze);
+    }
+  }
+
+  const celestialX = Math.round(((width - 6) * environment.sky.progress) + 3);
+  const celestialY = environment.sky.name === "night" ? 1 : Math.max(0, 2 - Math.round(environment.sky.progress * 2));
+  paint(
+    buffer,
+    celestialX,
+    celestialY,
+    environment.sky.name === "night" ? "◐" : "●",
+    environment.sky.celestial,
+  );
+}
+
+function drawWeather(buffer, width, environment, tick) {
+  const scene = getDynamicScene({ animals: [] }, width, tick, environment);
+  if (environment.weather.name === "rain") {
+    for (const drop of scene.particles) {
+      if (drop.kind !== "rain") continue;
+      paint(buffer, Math.round(drop.x), Math.round(drop.y), "╲", "#8ecae6");
+    }
+  }
+
+  if (environment.weather.name === "aurora") {
+    for (const band of scene.particles) {
+      if (band.kind !== "aurora") continue;
+      paint(buffer, band.x, Math.round(band.y), "~", band.alpha > 0.45 ? "#80ffdb" : "#64dfdf");
+    }
+  }
+
+  if (environment.weather.name === "rainbow") {
+    const midpoint = Math.floor(width / 2);
+    const colors = ["#f94144", "#f8961e", "#f9c74f", "#90be6d", "#577590"];
+    colors.forEach((color, index) => {
+      paint(buffer, midpoint - 2 + index, 1 + (index % 2), "◜", color);
+      paint(buffer, midpoint + 1 - index, 1 + (index % 2), "◝", color);
+    });
+  }
+}
+
+function drawSeasonParticles(buffer, width, environment, tick) {
+  const scene = getDynamicScene({ animals: [] }, width, tick, environment);
+  for (const particle of scene.particles) {
+    if (particle.kind === "petal") {
+      paint(buffer, Math.round(particle.x), Math.round(particle.y), "•", "#ffcad4");
+    }
+    if (particle.kind === "leaf") {
+      paint(buffer, Math.round(particle.x), Math.round(particle.y), "•", "#f6bd60");
+    }
+    if (particle.kind === "snow") {
+      paint(buffer, Math.round(particle.x), Math.round(particle.y), "*", "#f1faee");
+    }
+    if (particle.kind === "firefly") {
+      paint(buffer, Math.round(particle.x), Math.round(particle.y), "•", "#fef08a");
+    }
+  }
+}
+
+function drawForest(buffer, width, state, environment, tick) {
+  const treeBaseY = SKY_ROWS + FOREST_ROWS - 1;
+  for (const tree of state.trees) {
+    compositeSprite(buffer, getTreeSprite(tree.species), tree.x_position, treeBaseY, environment.palette);
+  }
+
+  for (const element of state.ground_elements) {
+    compositeSprite(buffer, getGroundElementSprite(element.type), element.x_position, ART_ROWS - 1, environment.palette);
+  }
+
+  const scene = getDynamicScene(state, width, tick, environment);
+  for (const animal of scene.animals) {
+    if (animal.type === "owl" && environment.sky.name !== "night") {
+      continue;
+    }
+    compositeSprite(
+      buffer,
+      getAnimalSprite(animal.type),
+      animal.x,
+      Math.min(ART_ROWS - 2, Math.round(animal.y)),
+      environment.palette,
+    );
+  }
+
+  // Llama companion
+  const llama = scene.llama;
+  if (llama) {
+    compositeSprite(
+      buffer,
+      getLlamaSprite(llama.pose),
+      llama.x,
+      Math.min(ART_ROWS - 2, llama.y),
+      environment.palette,
+    );
+  }
+}
+
+function drawGround(buffer, width, environment) {
+  for (let x = 0; x < width; x += 1) {
+    paint(buffer, x, ART_ROWS - 1, "▄", x % 3 === 0 ? environment.palette.groundLight : environment.palette.ground);
+  }
+}
+
+function buildStatsLine(state, environment, width, color) {
+  const trees = `${state.trees.length} tree${state.trees.length === 1 ? "" : "s"}`;
+  const animals = `${state.animals.length} animal${state.animals.length === 1 ? "" : "s"}`;
+  const streak = `${state.current_streak} day streak`;
+  const weather = `${environment.season.icon} ${environment.season.label} ${environment.weather.label}`;
+  const separator = colorize(" • ", "#6b7280", color);
+  const line = [
+    colorize("🌲 " + trees, "#7bd389", color),
+    colorize("🐇 " + animals, "#f4d35e", color),
+    colorize("🔥 " + streak, "#ee964b", color),
+    colorize(weather, "#d4d4d8", color),
+  ].join(separator);
+
+  if (line.length >= width) {
+    return line.slice(0, width);
+  }
+  return line.padEnd(width, " ");
+}
+
+export function buildTerminalScene(state, termWidth = 80, tick = 0, options = {}) {
+  const width = Math.max(20, termWidth);
+  const date = options.now instanceof Date ? options.now : new Date();
+  const environment = getEnvironmentSnapshot(date, state.current_streak ?? 0);
+  const buffer = createBuffer(width);
+
+  drawSky(buffer, width, environment, tick);
+  drawWeather(buffer, width, environment, tick);
+  drawSeasonParticles(buffer, width, environment, tick);
+  drawForest(buffer, width, state, environment, tick);
+  drawGround(buffer, width, environment);
+
+  return {
+    width,
+    environment,
+    buffer,
+    statsLine: buildStatsLine(state, environment, width, options.color !== false),
+  };
+}
+
+export function renderTerminalFrame(state, termWidth = 80, tick = 0, options = {}) {
+  if (termWidth < 20) {
+    const environment = getEnvironmentSnapshot(
+      options.now instanceof Date ? options.now : new Date(),
+      state.current_streak ?? 0,
+    );
+    return buildStatsLine(state, environment, Math.max(20, termWidth), options.color !== false);
+  }
+
+  const scene = buildTerminalScene(state, termWidth, tick, options);
+  const lines = scene.buffer.map((row) =>
+    row
+      .map((cell) => colorize(cell.char, cell.color, options.color !== false))
+      .join(""),
+  );
+  lines.push(scene.statsLine);
+  return lines.join("\n");
+}
+

package/src/tracker/activity.js

@@ -0,0 +1,43 @@
+export function createActivityTracker({
+  onMinutes,
+  now = () => Date.now(),
+  activeWindowMs = 5 * 60 * 1000,
+} = {}) {
+  let lastTickAt = now();
+  let lastActiveAt = 0;
+  let carriedMs = 0;
+
+  function markActive(at = now()) {
+    lastActiveAt = at;
+  }
+
+  function tick(at = now()) {
+    const elapsed = Math.max(0, at - lastTickAt);
+    lastTickAt = at;
+
+    if (!lastActiveAt || at - lastActiveAt > activeWindowMs) {
+      carriedMs = 0;
+      return 0;
+    }
+
+    carriedMs += elapsed;
+    const wholeMinutes = Math.floor(carriedMs / 60_000);
+    if (wholeMinutes > 0) {
+      carriedMs -= wholeMinutes * 60_000;
+      onMinutes?.(wholeMinutes, at);
+    }
+    return wholeMinutes;
+  }
+
+  return {
+    markActive,
+    tick,
+    start({ intervalMs = 60_000 } = {}) {
+      const timer = setInterval(() => {
+        tick(now());
+      }, intervalMs);
+      return () => clearInterval(timer);
+    },
+  };
+}
+

package/src/tracker/files.js

@@ -0,0 +1,44 @@
+import chokidar from "chokidar";
+
+const IGNORED_SEGMENTS = [
+  "/.git/",
+  "/node_modules/",
+  "/dist/",
+  "/build/",
+  "/coverage/",
+  "/.next/",
+  "/out/",
+];
+
+export function shouldTrackPath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return !IGNORED_SEGMENTS.some((segment) => normalized.includes(segment));
+}
+
+export function startFileTracker({
+  cwd = process.cwd(),
+  onSave,
+  watchImpl = chokidar.watch,
+} = {}) {
+  const watcher = watchImpl(cwd, {
+    ignored: (filePath) => !shouldTrackPath(filePath),
+    ignoreInitial: true,
+    persistent: true,
+  });
+
+  const handleChange = (filePath) => {
+    if (shouldTrackPath(filePath)) {
+      onSave?.(filePath);
+    }
+  };
+
+  watcher.on("add", handleChange);
+  watcher.on("change", handleChange);
+
+  return {
+    close() {
+      return watcher.close();
+    },
+  };
+}
+

package/src/tracker/git.js

@@ -0,0 +1,77 @@
+import simpleGit from "simple-git";
+
+export async function detectNewCommits({
+  cwd = process.cwd(),
+  lastCommitHash = "",
+  git = simpleGit({ baseDir: cwd }),
+} = {}) {
+  try {
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+      return { isRepo: false, latestHash: lastCommitHash, newCommits: [] };
+    }
+
+    const log = await git.log({ maxCount: 25 });
+    const latestHash = log.latest?.hash ?? lastCommitHash;
+    if (!latestHash || !lastCommitHash) {
+      return { isRepo: true, latestHash, newCommits: [] };
+    }
+
+    const newCommits = [];
+    for (const entry of log.all) {
+      if (entry.hash === lastCommitHash) {
+        break;
+      }
+      newCommits.push(entry.hash);
+    }
+
+    return {
+      isRepo: true,
+      latestHash,
+      newCommits: newCommits.reverse(),
+    };
+  } catch {
+    return { isRepo: false, latestHash: lastCommitHash, newCommits: [] };
+  }
+}
+
+export function startGitTracker({
+  cwd = process.cwd(),
+  lastCommitHash = "",
+  pollMs = 30_000,
+  onCommit,
+  gitFactory = (baseDir) => simpleGit({ baseDir }),
+} = {}) {
+  const git = gitFactory(cwd);
+  let currentHash = lastCommitHash;
+  let stopped = false;
+
+  async function poll() {
+    if (stopped) {
+      return { isRepo: false, latestHash: currentHash, newCommits: [] };
+    }
+
+    const result = await detectNewCommits({ cwd, lastCommitHash: currentHash, git });
+    currentHash = result.latestHash || currentHash;
+
+    for (const commitHash of result.newCommits) {
+      await onCommit?.(commitHash);
+      currentHash = commitHash;
+    }
+
+    return result;
+  }
+
+  const timer = setInterval(() => {
+    poll().catch(() => {});
+  }, pollMs);
+
+  return {
+    poll,
+    stop() {
+      stopped = true;
+      clearInterval(timer);
+    },
+  };
+}
+

package/src/init.js

@@ -1,86 +0,0 @@
-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 });
-
-  const existing = readForest();
-  if (!existing) {
-    writeForest(createEmptyForest());
-    console.log(`Created ${path.join(honeydewDir, "forest.json")}`);
-  } else {
-    let migrated = false;
-    if (existing.lastActiveDate === undefined) {
-      existing.lastActiveDate = new Date().toISOString().slice(0, 10);
-      migrated = true;
-    }
-    if (existing.streak === undefined) {
-      existing.streak = 0;
-      migrated = true;
-    }
-    if (migrated) {
-      writeForest(existing);
-      console.log(`Updated forest with streak tracking (${existing.trees.length} trees kept)`);
-    } else {
-      console.log(`Forest already up to date 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

@@ -1,101 +0,0 @@
-import { getSprite, TREE_TYPES } from "./sprites.js";
-import { createEmptyForest, readForest, writeForest } from "./state.js";
-
-const MIN_GAP = 4;
-const DEFAULT_WIDTH = 80;
-
-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;
-}
-
-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);
-
-  // 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);
-}