honeytree 1.2.0 → 1.2.1

package/README.md

@@ -5,77 +5,67 @@
 [![npm version](https://img.shields.io/npm/v/honeytree.svg)](https://www.npmjs.com/package/honeytree)
 [![license](https://img.shields.io/npm/l/honeytree.svg)](https://github.com/Varun2009178/honeytree/blob/main/LICENSE)
 
-A 3D forest that grows from your codebase. Every file becomes a tree — rendered as a rotatable point cloud right in your terminal using block characters (░▒▓█).
+Honeytree grows a pixel-art forest in your terminal as you code with Claude Code. Then it lets you plant real ones.
 
-No browser. No app. No install beyond npm.
+## Quick start
 
 ```bash
-npx honeytree
+npm install -g honeytree
+honeytree init
+honeytree login
+honeytree
 ```
 
-That's it. One command. Run it in any project directory.
+`honeytree init` registers a Claude Code hook that plants a tree after every prompt. `honeytree login` links your terminal to your account so your forest syncs to the cloud. Open a second terminal pane, run `honeytree`, and watch your forest grow in real time.
 
----
+**Live growth:** keep `honeytree` open in a second pane while you use Claude Code — the
+current turn's tree grows in real time as the response streams, and bigger turns grow
+taller trees. One prompt still plants one tree.
 
-## What You See
+## Tree varieties
 
-- Each **file** is a **tree**
-- **Tree height** = file size (bigger files are taller)
-- **Tree species/color** = file type
-- **Canopy density** = git churn (more commits = denser canopy)
-- **Spatial layout** = directory structure (files in the same folder cluster together)
+New trees are drawn from the varieties you've unlocked. Everyone starts with the
+standard species (birch, willow); planting real trees unlocks more:
 
-### Species
+| Variety | Real trees | Look |
+|---------|-----------|------|
+| Cherry Blossom | 1 | Pink blossom canopy |
+| Pine | 5 | Tall evergreen |
+| Oak | 10 | Broad rounded canopy |
+| Ancient | 25 | Rare tall golden tree |
+| Mythic | 50 | Glowing purple tree |
 
-| Extension | Species | Color | Shape |
-|-----------|---------|-------|-------|
-| `.js` `.jsx` `.mjs` | Oak | Bright green | Wide ellipsoid |
-| `.ts` `.tsx` | Pine | Teal | Narrow cone |
-| `.css` `.scss` | Birch | Pink | Slim ellipsoid |
-| `.py` | Willow | Lime green | Drooping |
-| `.md` `.json` `.yaml` | Cherry | Pink-purple | Sphere |
-
----
-
-## Controls
-
-| Input | Action |
-|-------|--------|
-| Mouse drag | Rotate the forest |
-| `+` / `=` | Zoom in |
-| `-` / `_` | Zoom out |
-| Arrow keys | Rotate camera |
-| Hover | Show file path (displayed at top) |
-| `r` | Rescan codebase |
-| `q` | Quit |
-
----
+The first time a new variety is unlocked, the viewer opens with a full-screen
+celebration screen. Check progress anytime with `honeytree rewards`.
 
-## Install Globally (optional)
+## Plant real trees
 
 ```bash
-npm install -g honeytree
-honeytree
-```
-
-Or point it at a specific directory:
-
-```bash
-honeytree view ~/my-project
+honeytree plant
 ```
 
----
+`honeytree plant` shows how many real trees you've unlocked (every 50 virtual trees = 1 real tree), opens a $1 checkout via the Good API, then prints your receipt and any newly-unlocked varieties right in the terminal. A keepsake receipt also lands in your inbox.
 
-## How It Works
+## Your public profile
 
-A custom terminal-based 3D engine:
+Every account gets a public profile at `tryhoney.xyz/<username>` — your forest, totals,
+CO₂ impact, and unlocked varieties, ready to share.
 
-1. **Scanner** — walks your project, collects file metadata (size, extension, git history)
-2. **Point cloud** — generates 3D points for each tree based on species shape
-3. **Camera** — orbital rotation with perspective projection
-4. **Rasterizer** — z-buffer depth sorting, block character shading, point splatting
+---
 
-Everything renders to Unicode block characters with 24-bit true color. No WebGL, no canvas, no browser — just your terminal.
+## CLI reference
+
+| Command | What it does |
+|---------|-------------|
+| `honeytree` | Open the forest viewer |
+| `honeytree init` | Register Claude Code hook |
+| `honeytree plant` | Plant your unlocked real trees |
+| `honeytree login` | Link terminal to your account |
+| `honeytree logout` | Remove stored credentials |
+| `honeytree sync` | Push forest to cloud |
+| `honeytree rewards` | Show variety unlocks and progress |
+| `honeytree status` | Check login status |
+| `honeytree badge` | Generate `honeytree-badge.svg` |
 
 ---
 

package/bin/honeydew.js

@@ -5,21 +5,84 @@ const command = process.argv[2];
 if (command === "init") {
   const { init } = await import("../src/init.js");
   await init();
+} else if (command === "__session") {
+  // Hidden: UserPromptSubmit hook — marks the start of a turn (token baseline + chosen tree).
+  try {
+    const { readStdin } = await import("../src/stdin.js");
+    const { startTurn } = await import("../src/turn.js");
+    const payload = JSON.parse((await readStdin()) || "{}");
+    startTurn(payload);
+  } catch {}
+} else if (command === "__tick") {
+  // Hidden: Stop hook — finalizes this turn's token-sized tree (random fallback).
+  const { tick } = await import("../src/plant.js");
+  let shape = null;
+  try {
+    const { readStdin } = await import("../src/stdin.js");
+    const { computeTickShape } = await import("../src/turn.js");
+    const payload = JSON.parse((await readStdin()) || "{}");
+    shape = computeTickShape(payload);
+  } catch {}
+  await tick(shape);
 } else if (command === "plant") {
-  const { plant } = await import("../src/plant.js");
+  const { plant } = await import("../src/plant-real.js");
   await plant();
 } else if (command === "badge") {
   const { badge } = await import("../src/badge.js");
   await badge();
-} else if (command === "md") {
-  const { generateForestMd } = await import("../src/markdown.js");
-  await generateForestMd();
-} else if (!command || command === "view") {
-  const targetDir = !command ? process.cwd() : process.argv[3] || process.cwd();
-  const { viewer } = await import("../src/viewer.js");
-  await viewer(targetDir);
+} else if (!command) {
+  const { viewer } = await import("../src/viewer2d.js");
+  await viewer();
+} else if (command === "login") {
+  const { loginWithDevice } = await import("../src/auth.js");
+  const success = await loginWithDevice();
+  if (success) {
+    const { syncNow } = await import("../src/sync.js");
+    console.log("  Syncing your forest...");
+    await syncNow();
+    console.log("  Forest synced to the cloud.");
+  }
+} else if (command === "logout") {
+  const { clearAuth } = await import("../src/auth.js");
+  clearAuth();
+  console.log("Logged out.");
+} else if (command === "sync") {
+  const { isLoggedIn } = await import("../src/auth.js");
+  if (!isLoggedIn()) {
+    console.log("Not logged in. Run: honeytree login");
+    process.exit(1);
+  }
+  const { syncNow } = await import("../src/sync.js");
+  const { syncRewards } = await import("../src/rewards.js");
+  console.log("  Syncing forest...");
+  await syncNow();
+  const rewards = await syncRewards();
+  if (rewards && rewards.badges.length > 0) {
+    console.log(`  Badges: ${rewards.badges.map(b => b.label).join(", ")}`);
+    if (rewards.cherry) console.log("  Cherry blossom trees unlocked!");
+  }
+  console.log("  Done.");
+} else if (command === "rewards") {
+  const { isLoggedIn } = await import("../src/auth.js");
+  const { syncRewards, printRewardsStatus } = await import("../src/rewards.js");
+  const { readForest } = await import("../src/state.js");
+  if (isLoggedIn()) {
+    console.log("  Fetching rewards...");
+    await syncRewards();
+  }
+  const forest = readForest();
+  const realTrees = 0; // local doesn't know real trees; printRewardsStatus uses cached data
+  printRewardsStatus(realTrees);
+} else if (command === "status") {
+  const { getAuth } = await import("../src/auth.js");
+  const auth = getAuth();
+  if (auth && auth.username) {
+    console.log(`Logged in as ${auth.username}`);
+  } else {
+    console.log("Not logged in. Run: honeytree login");
+  }
 } else {
   console.error(`Unknown command: ${command}`);
-  console.error("Usage: honeytree [init|plant|badge|md|view <dir>]");
+  console.error("Usage: honeytree [init|login|plant|badge|logout|sync|status|rewards]");
   process.exit(1);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "honeytree",
-  "version": "1.2.0",
-  "description": "Your codebase is a forest — 3D terminal visualization of any codebase",
+  "version": "1.2.1",
+  "description": "code with claude, and watch your forest grow! ",
   "type": "module",
   "bin": {
     "honeytree": "./bin/honeydew.js"
@@ -34,7 +34,10 @@
   "author": "Varun Nukala",
   "license": "MIT",
   "dependencies": {
-    "chalk": "^5.4.1"
+    "chalk": "^5.4.1",
+    "honeytree": "^1.2.0",
+    "ink": "^7.0.4",
+    "react": "^19.2.6"
   },
   "engines": {
     "node": ">=18"

package/src/ascii-tree.js

@@ -0,0 +1,21 @@
+const TREE = `
+       /\\
+      /  \\
+     /    \\
+    /______\\
+       ||
+       ||
+`;
+
+const TREE_BLOSSOM = `
+      .::.
+    .:(@@):.
+   :(@@@@@@):
+    ':(@@):'
+       ||
+       ||
+`;
+
+export function asciiTree(hasBloomer) {
+  return hasBloomer ? TREE_BLOSSOM : TREE;
+}

package/src/auth.js

@@ -0,0 +1,83 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const AUTH_DIR = path.join(os.homedir(), ".honeydew");
+const AUTH_FILE = path.join(AUTH_DIR, "auth.json");
+
+export function getAuth() {
+  try {
+    return JSON.parse(fs.readFileSync(AUTH_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export function saveAuth(data) {
+  fs.mkdirSync(AUTH_DIR, { recursive: true });
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2));
+}
+
+export function clearAuth() {
+  try {
+    fs.unlinkSync(AUTH_FILE);
+  } catch {}
+}
+
+export function isLoggedIn() {
+  const auth = getAuth();
+  return !!(auth && auth.access_token);
+}
+
+export async function loginWithDevice(apiUrl = process.env.HONEYTREE_API_URL || "https://tryhoney.xyz") {
+  const res = await fetch(`${apiUrl}/api/auth/device`, { method: "POST" });
+  const contentType = res.headers.get("content-type") || "";
+  if (!contentType.includes("application/json")) {
+    console.error("  Server returned unexpected response. Is the Honeytree web app running?");
+    return false;
+  }
+  const { device_code, user_code, interval } = await res.json();
+
+  console.log();
+  console.log(`  Your code: ${user_code}`);
+  console.log();
+  console.log("  Enter this code on your Honeytree dashboard to link your terminal.");
+  console.log("  Waiting...");
+
+  while (true) {
+    await new Promise((r) => setTimeout(r, (interval || 5) * 1000));
+
+    try {
+      const pollRes = await fetch(`${apiUrl}/api/auth/device/poll`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ device_code }),
+      });
+
+      const pollContentType = pollRes.headers.get("content-type") || "";
+      if (!pollContentType.includes("application/json")) continue;
+
+      if (!pollRes.ok) {
+        if (pollRes.status === 410) {
+          console.error("  Code expired. Run honeytree login again.");
+          return false;
+        }
+        continue;
+      }
+
+      const data = await pollRes.json();
+
+      if (data.status === "complete") {
+        saveAuth({
+          access_token: data.access_token,
+          user_id: data.user.id,
+          username: data.user.username,
+        });
+        console.log(`  Linked as ${data.user.username}`);
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+}