honeytree 1.1.6 → 1.2.0

package/src/renderer3d.js

@@ -0,0 +1,135 @@
+import chalk from "chalk";
+
+chalk.level = 3; // force 24-bit true color
+
+const BLOCK_CHARS = ["█", "▓", "▒", "░"];
+const BG_COLOR = "#0a0a1a";
+
+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(hex, targetHex, factor) {
+  const c = parseHex(hex);
+  const t = parseHex(targetHex);
+  return toHex({
+    r: c.r + (t.r - c.r) * factor,
+    g: c.g + (t.g - c.g) * factor,
+    b: c.b + (t.b - c.b) * factor,
+  });
+}
+
+export function createFrameBuffer(width, height) {
+  const chars = Array.from({ length: height }, () =>
+    Array.from({ length: width }, () => ({ char: " ", color: null }))
+  );
+  const depth = Array.from({ length: height }, () =>
+    new Float64Array(width).fill(Infinity)
+  );
+  const fileIndices = Array.from({ length: height }, () =>
+    new Int32Array(width).fill(-1)
+  );
+
+  return { chars, depth, fileIndices, width, height };
+}
+
+export function rasterize(buf, projectedPoints, depthRange = null) {
+  let minDepth = Infinity;
+  let maxDepth = -Infinity;
+
+  if (depthRange) {
+    minDepth = depthRange.minDepth;
+    maxDepth = depthRange.maxDepth;
+  } else {
+    for (const p of projectedPoints) {
+      if (!p.visible) continue;
+      if (p.depth < minDepth) minDepth = p.depth;
+      if (p.depth > maxDepth) maxDepth = p.depth;
+    }
+  }
+
+  const depthSpan = maxDepth - minDepth || 1;
+
+  for (const p of projectedPoints) {
+    if (!p.visible) continue;
+
+    const sx = p.screenX;
+    const sy = p.screenY;
+
+    const t = (p.depth - minDepth) / depthSpan;
+    const charIndex = t === 0 ? 0 : Math.min(BLOCK_CHARS.length - 1, Math.ceil(t * BLOCK_CHARS.length) - 1);
+    const blockChar = BLOCK_CHARS[charIndex];
+    const dimFactor = t * 0.6;
+    const dimmedColor = lerpColor(p.color, BG_COLOR, dimFactor);
+
+    // Point splatting — closer points splat larger (2x2 for near, 1x1 for far)
+    const splatRadius = t < 0.3 ? 2 : t < 0.7 ? 1 : 0;
+
+    for (let dy = -splatRadius; dy <= splatRadius; dy++) {
+      for (let dx = -splatRadius; dx <= splatRadius; dx++) {
+        const px = sx + dx;
+        const py = sy + dy;
+
+        if (px < 0 || px >= buf.width || py < 0 || py >= buf.height) continue;
+
+        if (p.depth < buf.depth[py][px]) {
+          buf.depth[py][px] = p.depth;
+          buf.fileIndices[py][px] = p.fileIndex;
+
+          // Edge pixels of splat use lighter block char
+          const edgeChar = (dx === 0 && dy === 0) ? blockChar : BLOCK_CHARS[Math.min(BLOCK_CHARS.length - 1, charIndex + 1)];
+          buf.chars[py][px] = { char: edgeChar, color: dimmedColor };
+        }
+      }
+    }
+  }
+}
+
+export function renderBufferToString(buf, bgColor = BG_COLOR, changedIndices = null) {
+  const lines = [];
+
+  for (let y = 0; y < buf.height; y++) {
+    let line = "";
+    for (let x = 0; x < buf.width; x++) {
+      const cell = buf.chars[y][x];
+      if (!cell.color) {
+        line += chalk.hex(bgColor)(" ");
+      } else {
+        let color = cell.color;
+        if (changedIndices && buf.fileIndices[y][x] >= 0 && !changedIndices.has(buf.fileIndices[y][x])) {
+          color = lerpColor(color, bgColor, 0.6);
+        }
+        line += chalk.hex(color)(cell.char);
+      }
+    }
+    lines.push(line);
+  }
+
+  return lines.join("\n");
+}
+
+export function renderTopBar(hoveredFile, width, modified = false) {
+  if (!hoveredFile) return " ".repeat(width);
+  const tag = modified ? " [modified]" : "";
+  const plainLen = hoveredFile.length + tag.length + 2;
+  const pad = Math.max(0, Math.floor((width - plainLen) / 2));
+  const fileText = chalk.hex("#f5a50b")(` ${hoveredFile}`);
+  const tagText = modified ? chalk.hex("#ff8822")(" [modified]") : "";
+  return " ".repeat(pad) + fileText + tagText + " " + " ".repeat(Math.max(0, width - pad - plainLen));
+}
+
+export function renderStatusBar(fileCount, width, prefix = "") {
+  const rightPart = `${prefix}${fileCount} files  |  drag to rotate  |  +/- zoom  |  d diff  |  q quit  r rescan `;
+  const padding = Math.max(0, width - rightPart.length);
+  return " ".repeat(padding) + chalk.hex("#8e8a84")(rightPart);
+}

package/src/scanner.js

@@ -0,0 +1,102 @@
+// src/scanner.js — walks project directory to collect file metadata
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+
+const IGNORE_DIRS = new Set([
+  "node_modules", ".git", ".hg", ".svn", "dist", "build",
+  ".next", "__pycache__", ".venv", "venv", "coverage",
+  ".superpowers", ".honeytree",
+]);
+
+const BINARY_EXTENSIONS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".webp",
+  ".mp3", ".mp4", ".wav", ".avi", ".mov", ".mkv",
+  ".zip", ".tar", ".gz", ".bz2", ".7z", ".rar",
+  ".exe", ".dll", ".so", ".dylib", ".o", ".a",
+  ".woff", ".woff2", ".ttf", ".eot", ".otf",
+  ".pdf", ".doc", ".docx", ".xls", ".xlsx",
+  ".lock", ".sqlite", ".db",
+]);
+
+export function scanDirectory(rootDir) {
+  const files = [];
+
+  function walk(dir, relativeBase) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".") {
+        if (entry.isDirectory()) continue;
+      }
+
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = relativeBase
+        ? `${relativeBase}/${entry.name}`
+        : entry.name;
+
+      if (entry.isDirectory()) {
+        if (IGNORE_DIRS.has(entry.name)) continue;
+        walk(fullPath, relativePath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (BINARY_EXTENSIONS.has(ext)) continue;
+
+        let stat;
+        try {
+          stat = fs.statSync(fullPath);
+        } catch {
+          continue;
+        }
+
+        files.push({
+          absolutePath: fullPath,
+          relativePath,
+          extension: ext,
+          size: stat.size,
+          directory: relativeBase || ".",
+        });
+      }
+    }
+  }
+
+  walk(rootDir, "");
+  return files;
+}
+
+export function getGitChurn(rootDir) {
+  try {
+    const output = execSync("git log --format= --name-only --diff-filter=ACMR", {
+      cwd: rootDir,
+      encoding: "utf-8",
+      timeout: 10000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    const counts = {};
+    for (const line of output.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      counts[trimmed] = (counts[trimmed] || 0) + 1;
+    }
+    return counts;
+  } catch {
+    return {};
+  }
+}
+
+export function scanCodebase(rootDir) {
+  const files = scanDirectory(rootDir);
+  const churn = getGitChurn(rootDir);
+
+  for (const file of files) {
+    file.churn = churn[file.relativePath] || 0;
+  }
+
+  return files;
+}

package/src/sprites.js

@@ -27,7 +27,7 @@ const DETAIL_COLORS = {
   bushLight: "#5a8a4a",
 };
 
-function parse(template, palette) {
+export function parse(template, palette) {
   const lines = template.trim().split("\n");
   const width = Math.max(...lines.map((line) => line.length));
   const rows = lines
@@ -300,3 +300,4 @@ export function getSprite(type, growth) {
   }
   return spriteSet[getGrowthStage(growth)];
 }
+