honeytree 1.1.5 → 1.2.0

package/src/animation.js

@@ -0,0 +1,151 @@
+import { ANIMATION_KEYFRAMES } from "./animation-keyframes.js";
+import { getSprite } from "./sprites.js";
+
+const CHAR_ORDER = [" ", "░", "▒", "█"];
+
+function charIndex(ch) {
+  const idx = CHAR_ORDER.indexOf(ch);
+  return idx >= 0 ? idx : 0;
+}
+
+function interpolateChar(ch1, ch2, t) {
+  const i1 = charIndex(ch1);
+  const i2 = charIndex(ch2);
+  const idx = Math.round(i1 + (i2 - i1) * t);
+  return CHAR_ORDER[Math.max(0, Math.min(CHAR_ORDER.length - 1, idx))];
+}
+
+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 lerpColor(hex1, hex2, t) {
+  const c1 = parseHex(hex1);
+  const c2 = parseHex(hex2);
+  return toHex({
+    r: c1.r + (c2.r - c1.r) * t,
+    g: c1.g + (c2.g - c1.g) * t,
+    b: c1.b + (c2.b - c1.b) * t,
+  });
+}
+
+function interpolateSprite(sprite1, sprite2, t) {
+  const rows = sprite1.rows.map((row, r) =>
+    row.map(([ch1, col1], c) => {
+      const [ch2, col2] = sprite2.rows[r][c];
+      if (!col1 && !col2) return [" ", null];
+      if (!col1 && col2) {
+        const ch = interpolateChar(" ", ch2, t);
+        if (ch === " ") return [" ", null];
+        return [ch, col2];
+      }
+      if (col1 && !col2) {
+        const ch = interpolateChar(ch1, " ", t);
+        if (ch === " ") return [" ", null];
+        return [ch, col1];
+      }
+      const ch = interpolateChar(ch1, ch2, t);
+      const col = lerpColor(col1, col2, t);
+      return [ch, col];
+    }),
+  );
+  return { rows, width: sprite1.width };
+}
+
+function brightenSprite(sprite, amount) {
+  const rows = sprite.rows.map((row) =>
+    row.map(([ch, col]) => {
+      if (!col) return [ch, col];
+      const c = parseHex(col);
+      return [ch, toHex({
+        r: Math.min(255, c.r + (255 - c.r) * amount),
+        g: Math.min(255, c.g + (255 - c.g) * amount),
+        b: Math.min(255, c.b + (255 - c.b) * amount),
+      })];
+    }),
+  );
+  return { rows, width: sprite.width };
+}
+
+export function getAnimationFrames(type, growth, frameCount = 40) {
+  const allKeyframes = ANIMATION_KEYFRAMES[type];
+  if (!allKeyframes) throw new Error(`No animation keyframes for type: ${type}`);
+
+  const finalSprite = getSprite(type, growth);
+
+  let keyframes;
+  if (growth >= 0.8) {
+    keyframes = allKeyframes;
+  } else {
+    let maxKF;
+    if (growth < 0.2) maxKF = 3;
+    else if (growth < 0.5) maxKF = 6;
+    else maxKF = 8;
+
+    keyframes = allKeyframes.slice(0, maxKF);
+    const lastTime = keyframes[keyframes.length - 1].time;
+    const timeScale = 4.0 / Math.max(lastTime, 0.1);
+
+    keyframes = keyframes.map((kf) => ({ ...kf, time: kf.time * timeScale }));
+    keyframes.push({ time: 4.0, sprite: finalSprite });
+    keyframes.push({ time: 4.5, sprite: brightenSprite(finalSprite, 0.2) });
+  }
+
+  const totalDuration = 5.0;
+  const frames = [];
+
+  for (let i = 0; i < frameCount; i++) {
+    const t = (i / (frameCount - 1)) * totalDuration;
+
+    let kfBefore = keyframes[0];
+    let kfAfter = keyframes[0];
+
+    for (let k = 0; k < keyframes.length - 1; k++) {
+      if (t >= keyframes[k].time && t <= keyframes[k + 1].time) {
+        kfBefore = keyframes[k];
+        kfAfter = keyframes[k + 1];
+        break;
+      }
+      if (k === keyframes.length - 2) {
+        kfBefore = keyframes[keyframes.length - 1];
+        kfAfter = keyframes[keyframes.length - 1];
+      }
+    }
+
+    const segmentDuration = kfAfter.time - kfBefore.time;
+    const segmentT = segmentDuration > 0 ? (t - kfBefore.time) / segmentDuration : 1;
+    const clampedT = Math.max(0, Math.min(1, segmentT));
+
+    const sprite = interpolateSprite(kfBefore.sprite, kfAfter.sprite, clampedT);
+
+    let groundOverlay = null;
+    if (t < 0.5 && kfBefore.groundEffect) {
+      const ge = kfBefore.groundEffect;
+      groundOverlay = [];
+      for (let dx = -ge.radius; dx <= ge.radius; dx++) {
+        const intensity = 1 - Math.abs(dx) / ge.radius;
+        if (intensity > 0.3) {
+          groundOverlay.push({ dx, char: "░", color: ge.color });
+        }
+      }
+    }
+
+    if (i === frameCount - 1) {
+      frames.push({ sprite: finalSprite, groundOverlay: null, groundPulse: false });
+    } else {
+      frames.push({ sprite, groundOverlay, groundPulse: i < 3 });
+    }
+  }
+
+  return frames;
+}

package/src/camera.js

@@ -0,0 +1,54 @@
+// src/camera.js
+
+const DEG_TO_RAD = Math.PI / 180;
+
+export function createCamera() {
+  return {
+    azimuth: 45,
+    elevation: 30,
+    distance: 60,
+  };
+}
+
+export function rotatePoint(x, y, z, azimuthDeg, elevationDeg) {
+  const az = azimuthDeg * DEG_TO_RAD;
+  const el = elevationDeg * DEG_TO_RAD;
+
+  const cosAz = Math.cos(az);
+  const sinAz = Math.sin(az);
+  const x1 = x * cosAz + z * sinAz;
+  const z1 = -x * sinAz + z * cosAz;
+
+  const cosEl = Math.cos(el);
+  const sinEl = Math.sin(el);
+  const y1 = y * cosEl - z1 * sinEl;
+  const z2 = y * sinEl + z1 * cosEl;
+
+  return [x1, y1, z2];
+}
+
+export function projectPoint(x, y, z, screenWidth, screenHeight, distance = 25) {
+  const fov = 60;
+  const fovRad = fov * DEG_TO_RAD;
+  const focalLength = screenHeight / (2 * Math.tan(fovRad / 2));
+
+  const zView = z - distance;
+
+  if (zView >= -1) {
+    return { screenX: -1, screenY: -1, depth: Infinity, visible: false };
+  }
+
+  const scale = focalLength / -zView;
+  const screenX = Math.round(x * scale * 2 + screenWidth / 2);
+  const screenY = Math.round(-y * scale + screenHeight / 2);
+
+  return { screenX, screenY, depth: -zView, visible: true };
+}
+
+export function clampElevation(elevation) {
+  return Math.max(10, Math.min(80, elevation));
+}
+
+export function clampAzimuth(azimuth) {
+  return ((azimuth % 360) + 360) % 360;
+}

package/src/diffactions.js

@@ -0,0 +1,32 @@
+import { execSync } from "node:child_process";
+import { hunkToPatch } from "./diffparser.js";
+
+export function stageHunk(rootDir, filePath, hunk) {
+  try {
+    const patch = hunkToPatch(filePath, hunk);
+    execSync("git apply --cached --unidiff-zero -", {
+      cwd: rootDir,
+      input: patch,
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+export function revertHunk(rootDir, filePath, hunk) {
+  try {
+    const patch = hunkToPatch(filePath, hunk);
+    execSync("git apply --reverse --unidiff-zero -", {
+      cwd: rootDir,
+      input: patch,
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}

package/src/diffpanel.js

@@ -0,0 +1,83 @@
+// src/diffpanel.js
+import chalk from "chalk";
+
+chalk.level = 3;
+
+export function createDiffPanel(filePath, hunks) {
+  return {
+    filePath,
+    hunks,
+    currentHunk: 0,
+    hunkStatus: hunks.map(() => "pending"),
+    scrollOffset: 0,
+  };
+}
+
+export function renderDiffPanel(panel, width, height) {
+  const lines = [];
+  const totalAdded = panel.hunks.reduce((s, h) => s + h.added, 0);
+  const totalRemoved = panel.hunks.reduce((s, h) => s + h.removed, 0);
+
+  // Header
+  const header = ` ${panel.filePath}  +${totalAdded} -${totalRemoved}  ${panel.hunks.length} hunks`;
+  lines.push(chalk.hex("#f5a50b").bold(header.padEnd(width).slice(0, width)));
+
+  // Separator
+  lines.push(chalk.hex("#555555")("─".repeat(width)));
+
+  // Help line
+  const help = " j/k: navigate  a: accept  r: reject  A/R: all  Esc: close";
+  lines.push(chalk.hex("#888888")(help.padEnd(width).slice(0, width)));
+
+  lines.push(chalk.hex("#555555")("─".repeat(width)));
+
+  // Render hunks
+  const bodyHeight = height - lines.length;
+  const bodyLines = [];
+
+  for (let hi = 0; hi < panel.hunks.length; hi++) {
+    const hunk = panel.hunks[hi];
+    const isCurrent = hi === panel.currentHunk;
+    const status = panel.hunkStatus[hi];
+
+    // Hunk header with status
+    let statusIcon = "[ ]";
+    if (status === "accepted") statusIcon = chalk.green("[✓]");
+    else if (status === "rejected") statusIcon = chalk.red("[✗]");
+
+    const hunkHeader = isCurrent
+      ? chalk.hex("#ffcc44").bold(`▸ Hunk ${hi + 1}/${panel.hunks.length} ${statusIcon} ${hunk.header}`)
+      : chalk.hex("#888888")(`  Hunk ${hi + 1}/${panel.hunks.length} ${statusIcon} ${hunk.header}`);
+
+    bodyLines.push(hunkHeader.padEnd(width).slice(0, width));
+
+    // Hunk lines
+    for (const line of hunk.lines) {
+      let rendered;
+      const text = line.text.padEnd(width).slice(0, width);
+      if (line.type === "added") {
+        rendered = chalk.green(text);
+      } else if (line.type === "removed") {
+        rendered = chalk.red(text);
+      } else {
+        rendered = isCurrent ? chalk.hex("#cccccc")(text) : chalk.hex("#666666")(text);
+      }
+      bodyLines.push(rendered);
+    }
+
+    bodyLines.push(""); // blank line between hunks
+  }
+
+  // Apply scroll offset and fill to height
+  const scrolled = bodyLines.slice(panel.scrollOffset, panel.scrollOffset + bodyHeight);
+  for (const line of scrolled) {
+    lines.push(line);
+  }
+
+  // Pad remaining height
+  while (lines.length < height) {
+    lines.push(" ".repeat(width));
+  }
+
+  return lines.slice(0, height);
+}

package/src/diffparser.js

@@ -0,0 +1,44 @@
+export function parseDiff(diffText) {
+  if (!diffText || !diffText.trim()) return [];
+
+  const lines = diffText.split("\n");
+  const hunks = [];
+  let currentHunk = null;
+
+  for (const line of lines) {
+    if (line.startsWith("@@")) {
+      if (currentHunk) {
+        currentHunk.added = currentHunk.lines.filter(l => l.type === "added").length;
+        currentHunk.removed = currentHunk.lines.filter(l => l.type === "removed").length;
+        hunks.push(currentHunk);
+      }
+      currentHunk = { header: line, lines: [], added: 0, removed: 0 };
+    } else if (currentHunk) {
+      if (line.startsWith("+")) {
+        currentHunk.lines.push({ type: "added", text: line });
+      } else if (line.startsWith("-")) {
+        currentHunk.lines.push({ type: "removed", text: line });
+      } else if (line.startsWith(" ") || line === "") {
+        currentHunk.lines.push({ type: "context", text: line });
+      }
+    }
+  }
+
+  if (currentHunk) {
+    currentHunk.added = currentHunk.lines.filter(l => l.type === "added").length;
+    currentHunk.removed = currentHunk.lines.filter(l => l.type === "removed").length;
+    hunks.push(currentHunk);
+  }
+
+  return hunks;
+}
+
+export function hunkToPatch(filePath, hunk) {
+  const lines = [
+    `--- a/${filePath}`,
+    `+++ b/${filePath}`,
+    hunk.header,
+    ...hunk.lines.map(l => l.text),
+  ];
+  return lines.join("\n") + "\n";
+}

package/src/diffwatch.js

@@ -0,0 +1,52 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+function execAsync(cmd, args, opts) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { timeout: 5000, encoding: "utf-8", ...opts }, (err, stdout) => {
+      resolve(err ? "" : stdout);
+    });
+  });
+}
+
+export async function getChangedFiles(rootDir) {
+  const changed = new Set();
+
+  const [tracked, untracked] = await Promise.all([
+    execAsync("git", ["diff", "--name-only"], { cwd: rootDir }),
+    execAsync("git", ["ls-files", "--others", "--exclude-standard"], { cwd: rootDir }),
+  ]);
+
+  for (const output of [tracked, untracked]) {
+    for (const line of output.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed) changed.add(trimmed);
+    }
+  }
+
+  return changed;
+}
+
+export function getFileDiff(rootDir, filePath) {
+  return execAsync("git", ["diff", "-U3", "--", filePath], { cwd: rootDir });
+}
+
+export function watchForChanges(rootDir, callback) {
+  let debounceTimer = null;
+  const debounced = () => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(callback, 300);
+  };
+
+  try {
+    const watcher = fs.watch(rootDir, { recursive: true }, (event, filename) => {
+      if (!filename) return;
+      if (filename.includes("node_modules") || filename.includes(".git")) return;
+      debounced();
+    });
+    return watcher;
+  } catch {
+    return null;
+  }
+}

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) {