honeytree 1.2.0 → 1.2.1

package/src/sync.js

@@ -0,0 +1,44 @@
+import { getAuth, saveAuth } from "./auth.js";
+import { readForest } from "./state.js";
+
+const API_URL = process.env.HONEYTREE_API_URL || "https://tryhoney.xyz";
+
+export async function syncToCloud(forest) {
+  const auth = getAuth();
+  if (!auth || !auth.access_token) return;
+
+  // Send tree data: type, growth, x position for rendering on the web
+  const trees = (forest.trees || []).map((t) => ({
+    type: t.type,
+    growth: t.growth,
+    x: t.x,
+  }));
+
+  try {
+    const res = await fetch(`${API_URL}/api/sync`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${auth.access_token}`,
+      },
+      body: JSON.stringify({
+        count: forest.totalPrompts,
+        streak: forest.streak || 0,
+        trees,
+      }),
+    });
+
+    if (res.ok) {
+      auth.lastSyncedPrompts = forest.totalPrompts;
+      saveAuth(auth);
+    }
+  } catch {
+    // Silently fail — sync is best-effort
+  }
+}
+
+// Immediate sync (called after login)
+export async function syncNow() {
+  const forest = readForest();
+  if (forest) await syncToCloud(forest);
+}

package/src/transcript.js

@@ -0,0 +1,62 @@
+import fs from "node:fs";
+
+function sumOutputTokens(text) {
+  let total = 0;
+  for (const raw of text.split("\n")) {
+    const t = raw.trim();
+    if (!t) continue;
+    try {
+      const obj = JSON.parse(t);
+      const ot = obj?.message?.usage?.output_tokens;
+      if (typeof ot === "number" && Number.isFinite(ot)) total += ot;
+    } catch {
+      // ignore malformed line
+    }
+  }
+  return total;
+}
+
+function readFrom(filePath, fromOffset, maxBytes = Infinity) {
+  let stat;
+  try {
+    stat = fs.statSync(filePath);
+  } catch {
+    return null;
+  }
+  if (stat.size <= fromOffset) return { text: "", size: stat.size };
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const len = Math.min(stat.size - fromOffset, maxBytes);
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, fromOffset);
+    return { text: buf.toString("utf8"), size: stat.size };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+// Cap each live tail read so a runaway/unterminated transcript line can't
+// allocate unbounded memory on the 1s viewer interval. The Stop-time full
+// read (readTurnTokens) stays uncapped so a turn is always totalled correctly.
+const MAX_LIVE_READ = 1024 * 1024;
+
+// Sum all output tokens from `fromOffset` to EOF (turn is complete at Stop).
+export function readTurnTokens(filePath, fromOffset) {
+  const r = readFrom(filePath, fromOffset);
+  if (!r) return 0;
+  return sumOutputTokens(r.text);
+}
+
+// Read only complete (newline-terminated) lines; leave a partial trailing line
+// for the next read by not advancing the offset past it.
+export function readNewTokens(filePath, fromOffset) {
+  const r = readFrom(filePath, fromOffset, MAX_LIVE_READ);
+  if (!r) return { tokens: 0, newOffset: fromOffset };
+  if (!r.text) return { tokens: 0, newOffset: fromOffset };
+  const lastNl = r.text.lastIndexOf("\n");
+  if (lastNl === -1) return { tokens: 0, newOffset: fromOffset };
+  const complete = r.text.slice(0, lastNl + 1);
+  const tokens = sumOutputTokens(complete);
+  const consumed = Buffer.byteLength(complete, "utf8");
+  return { tokens, newOffset: fromOffset + consumed };
+}

package/src/turn.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import { readForest, createEmptyForest } from "./state.js";
+import { getUnlockedVarietyKeys } from "./rewards.js";
+import { unlockedPool, pickSpecies } from "./varieties.js";
+import { getPlantWidth, findOpenX } from "./plant.js";
+import { writeActiveSession, readActiveSession, clearActiveSession } from "./session.js";
+import { readTurnTokens } from "./transcript.js";
+import { tokensToTree } from "./growth.js";
+
+function fileSize(p) {
+  try {
+    return fs.statSync(p).size;
+  } catch {
+    return 0;
+  }
+}
+
+// UserPromptSubmit: mark the start of a turn and pre-choose the tree (type + x)
+// so the live overlay and the committed tree are the same tree.
+export function startTurn(payload) {
+  const transcript_path = payload?.transcript_path;
+  if (!transcript_path) return;
+
+  const forest = readForest() ?? createEmptyForest();
+  const species = pickSpecies(unlockedPool(getUnlockedVarietyKeys()));
+  const type = species.type;
+  const variant = species.variant ?? null;
+  const width = getPlantWidth(forest);
+  const x = findOpenX(forest.trees, type, 1, width);
+
+  writeActiveSession({
+    transcript_path,
+    session_id: payload.session_id ?? null,
+    turnStartedAt: Date.now(),
+    baselineOffset: fileSize(transcript_path),
+    type,
+    variant,
+    x,
+  });
+}
+
+// Stop: total this turn's output tokens and produce the tree shape, then clear
+// the session. Returns null if there's no matching active session.
+export function computeTickShape(payload) {
+  const session = readActiveSession();
+  const transcript_path = payload?.transcript_path ?? session?.transcript_path;
+  if (!session || !transcript_path || session.transcript_path !== transcript_path) {
+    return null;
+  }
+  const tokens = readTurnTokens(transcript_path, session.baselineOffset || 0);
+  const shape = tokensToTree(tokens);
+  clearActiveSession();
+  return { ...shape, type: session.type, variant: session.variant ?? null, x: session.x, tokens };
+}

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/camera.js

@@ -1,54 +0,0 @@
-// 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

@@ -1,32 +0,0 @@
-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

@@ -1,83 +0,0 @@
-// 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

@@ -1,44 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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/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.");
-}