honeytree 1.1.6 → 1.2.0

package/src/viewer.js

@@ -1,9 +1,27 @@
-import fs from "node:fs";
+import chalk from "chalk";
+import { scanCodebase } from "./scanner.js";
+import { generateForestCloud, generateGroundPlane } from "./pointcloud.js";
+import { createCamera, rotatePoint, projectPoint, clampElevation, clampAzimuth } from "./camera.js";
+import { createFrameBuffer, rasterize, renderBufferToString, renderTopBar, renderStatusBar } from "./renderer3d.js";
+import { getChangedFiles, getFileDiff, watchForChanges } from "./diffwatch.js";
+import { parseDiff } from "./diffparser.js";
+import { createDiffPanel, renderDiffPanel } from "./diffpanel.js";
+import { stageHunk, revertHunk } from "./diffactions.js";
+
+export function createForestWatcher(filePath, onChange) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) return null;
 
-import { renderFrame } from "./renderer.js";
-import { getForestFile, readForest, writeForest } from "./state.js";
-import { migrateLayout } from "./migrate.js";
-import { getVirtualWidth } from "./plant.js";
+    const watcher = fs.watch(filePath, onChange);
+    watcher.on("error", () => {
+      try { watcher.close(); } catch {}
+    });
+    return watcher;
+  } catch {
+    return null;
+  }
+}
 
 function writeAnsi(code) {
   process.stdout.write(code);
@@ -25,210 +43,419 @@ function moveHome() {
   writeAnsi("\x1b[H");
 }
 
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function enableMouse() {
+  writeAnsi("\x1b[?1000h");
+  writeAnsi("\x1b[?1002h");
+  writeAnsi("\x1b[?1006h");
+}
+
+function disableMouse() {
+  writeAnsi("\x1b[?1006l");
+  writeAnsi("\x1b[?1002l");
+  writeAnsi("\x1b[?1000l");
 }
 
-export async function viewer() {
-  const forestFile = getForestFile();
-  let forest = readForest();
+function enableMouseMotion() {
+  writeAnsi("\x1b[?1003h");
+}
+
+function disableMouseMotion() {
+  writeAnsi("\x1b[?1003l");
+}
 
-  if (!forest || !fs.existsSync(forestFile)) {
-    console.error('No forest found. Run "honeytree init" first.');
+export async function viewer(targetDir) {
+  const dir = targetDir || process.cwd();
+
+  process.stdout.write("Scanning codebase...\n");
+  const files = scanCodebase(dir);
+
+  if (files.length === 0) {
+    console.error("No source files found in", dir);
     process.exit(1);
   }
 
-  // Migrate old layouts on first view
-  if (forest && (!forest.layoutVersion || forest.layoutVersion < 2)) {
-    const termWidth = process.stdout.columns || 80;
-    migrateLayout(forest, termWidth);
-    // Will be written to disk by syncWidth below
-  }
+  const { points: treePoints, filePaths } = generateForestCloud(files);
+  const groundRadius = Math.max(25, Math.sqrt(files.length) * 7);
+  const groundPoints = generateGroundPlane(groundRadius);
+  const allPoints = [...treePoints, ...groundPoints];
+
+  const camera = createCamera();
+  let mouseDown = false;
+  let lastMouseX = 0;
+  let lastMouseY = 0;
+  let hoveredFile = "";
+  let hoveredModified = false;
+  let needsRedraw = true;
+
+  let changedFiles = new Set();
+  let diffPanel = null;
+  let diffMode = false;
+  let polling = false;
+  let watcher = null;
+
+  let screenWidth = process.stdout.columns || 80;
+  let screenHeight = (process.stdout.rows || 24) - 2;
+
+  function renderFrame() {
+    screenWidth = process.stdout.columns || 80;
+    screenHeight = (process.stdout.rows || 24) - 2;
+
+    const forestWidth = diffPanel ? Math.floor(screenWidth * 0.4) : screenWidth;
+    const buf = createFrameBuffer(forestWidth, screenHeight);
+
+    const projected = [];
+    for (const p of allPoints) {
+      const [rx, ry, rz] = rotatePoint(p.x, p.y, p.z, camera.azimuth, camera.elevation);
+      const proj = projectPoint(rx, ry, rz, forestWidth, screenHeight, camera.distance);
+      if (proj.visible) {
+        projected.push({
+          ...proj,
+          color: p.color,
+          fileIndex: p.fileIndex,
+        });
+      }
+    }
+
+    rasterize(buf, projected);
+
+    const changedIndices = diffMode
+      ? new Set(files.map((f, i) => f.changed ? i : -1).filter(i => i >= 0))
+      : null;
+
+    moveHome();
+    process.stdout.write(renderTopBar(hoveredFile, screenWidth, hoveredModified));
+    process.stdout.write("\n");
+
+    const forestLines = renderBufferToString(buf, undefined, changedIndices).split("\n");
 
-  // Save terminal width so plant knows how wide to spread trees
-  let ignoreNextChange = false;
-  function syncWidth() {
-    const cols = process.stdout.columns || 80;
-    if (forest.viewerWidth !== cols) {
-      forest.viewerWidth = cols;
-      ignoreNextChange = true;
-      writeForest(forest);
+    if (diffPanel) {
+      const panelWidth = screenWidth - forestWidth - 1;
+      const panelLines = renderDiffPanel(diffPanel, panelWidth, screenHeight);
+      const border = chalk.hex("#555555")("│");
+
+      for (let y = 0; y < screenHeight; y++) {
+        const fLine = forestLines[y] || "";
+        const pLine = panelLines[y] || "";
+        process.stdout.write(fLine + border + pLine);
+        if (y < screenHeight - 1) process.stdout.write("\n");
+      }
+    } else {
+      process.stdout.write(forestLines.join("\n"));
     }
-  }
 
-  let lastMaxId = forest.trees.reduce((max, tree) => Math.max(max, tree.id), 0);
-  let lastTotalPrompts = forest.totalPrompts;
-  let animating = false;
+    process.stdout.write("\n");
 
-  let viewportX = forest.viewportX || 0;
-  const PAN_STEP = 4;
+    const changedCount = changedFiles.size;
+    const changeText = changedCount > 0 ? `${changedCount} files changed  |  ` : "";
+    process.stdout.write(renderStatusBar(files.length, screenWidth, changeText));
 
-  function getViewportWidth() {
-    return process.stdout.columns || 80;
+    return buf;
   }
 
-  function clampViewport(x) {
-    const vw = getVirtualWidth(forest.trees.length, getViewportWidth());
-    return Math.max(0, Math.min(x, Math.max(0, vw - getViewportWidth())));
+  function regeneratePoints() {
+    const { points: newTreePoints, filePaths: newPaths } = generateForestCloud(files);
+    const newGround = generateGroundPlane(groundRadius);
+    allPoints.length = 0;
+    allPoints.push(...newTreePoints, ...newGround);
+    filePaths.length = 0;
+    filePaths.push(...newPaths);
   }
 
-  function renderForest(forest, twinkleSeed = 0) {
-    clearScreen();
-    const termWidth = process.stdout.columns || 80;
-    const vw = getVirtualWidth(forest.trees.length, termWidth);
-    process.stdout.write(renderFrame(forest, termWidth, {
-      twinkleSeed,
-      viewportX,
-      virtualWidth: vw,
-    }));
-  }
+  async function pollChanges() {
+    if (polling) return;
+    polling = true;
+    try {
+      const newChanged = await getChangedFiles(dir);
+      const changed = newChanged.size !== changedFiles.size ||
+        [...newChanged].some(f => !changedFiles.has(f));
+      changedFiles = newChanged;
+
+      for (const file of files) {
+        file.changed = changedFiles.has(file.relativePath);
+      }
 
-  async function animateNewTree(forest, newTreeId) {
-    const tree = forest.trees.find((entry) => entry.id === newTreeId);
-    if (!tree) {
-      renderForest(forest);
-      return;
+      if (changed) {
+        regeneratePoints();
+        needsRedraw = true;
+        redraw();
+      }
+    } catch {
+      // ignore poll errors
     }
+    polling = false;
+  }
 
-    const originalGrowth = tree.growth;
-    const frames = [0.12, 0.32, 0.6, originalGrowth].filter(
-      (value, index, values) => value <= originalGrowth && values.indexOf(value) === index,
-    );
+  function checkAllResolved() {
+    if (!diffPanel) return;
+    const allDone = diffPanel.hunkStatus.every(s => s !== "pending");
+    if (!allDone) return;
 
-    for (let index = 0; index < frames.length; index += 1) {
-      tree.growth = frames[index];
-      renderForest(forest, index);
-      await delay(120);
+    for (let i = 0; i < diffPanel.hunks.length; i++) {
+      if (diffPanel.hunkStatus[i] === "accepted") {
+        stageHunk(dir, diffPanel.filePath, diffPanel.hunks[i]);
+      } else if (diffPanel.hunkStatus[i] === "rejected") {
+        revertHunk(dir, diffPanel.filePath, diffPanel.hunks[i]);
+      }
     }
 
-    tree.growth = originalGrowth;
-    renderForest(forest);
+    diffPanel = null;
+    clearScreen();
+    pollChanges();
   }
 
-  syncWidth();
   hideCursor();
   clearScreen();
-  renderForest(forest);
+  enableMouse();
+  enableMouseMotion();
+
+  // Render first frame before starting change detection
+  let currentBuf = renderFrame();
+  needsRedraw = false;
+
+  // Start async change detection after first render
+  pollChanges();
+
+  // Watch filesystem for instant change detection
+  watcher = watchForChanges(dir, () => pollChanges());
+
+  // Fallback poll every 3 seconds in case fs.watch misses events
+  const pollTimer = setInterval(() => pollChanges(), 3000);
+
+  function redraw() {
+    if (!needsRedraw) return;
+    needsRedraw = false;
+    try {
+      currentBuf = renderFrame();
+    } catch {
+      // swallow render errors to prevent terminal corruption
+    }
+  }
+
+  function parseMouseEvent(data) {
+    const str = data.toString();
+    const match = str.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
+    if (!match) return null;
+
+    const button = parseInt(match[1]);
+    const x = parseInt(match[2]) - 1;
+    const y = parseInt(match[3]) - 1;
+    const released = match[4] === "m";
+
+    return { button, x, y, released };
+  }
 
   const cleanup = () => {
-    // Persist viewport position for next session
-    forest.viewportX = viewportX;
-    ignoreNextChange = true;
-    writeForest(forest);
+    clearInterval(pollTimer);
+    if (watcher) watcher.close();
+    disableMouseMotion();
+    disableMouse();
     showCursor();
     clearScreen();
-    console.log(
-      `Forest summary: ${forest.trees.length} trees across ${forest.totalPrompts} prompts`,
-    );
+    console.log(`Scanned ${files.length} files in ${dir}`);
     process.exit(0);
   };
 
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   process.stdout.on("resize", () => {
-    syncWidth();
+    needsRedraw = true;
     clearScreen();
-    renderForest(forest);
+    redraw();
   });
 
-  // Enable raw mode for keypress handling
   if (process.stdin.isTTY) {
     process.stdin.setRawMode(true);
     process.stdin.resume();
     process.stdin.on("data", (data) => {
       const key = data.toString();
-      // Ctrl+C or q to quit
+
       if (key === "\x03" || key === "q") {
         cleanup();
         return;
       }
-      // Left arrow: \x1b[D
-      if (key === "\x1b[D") {
-        viewportX = clampViewport(viewportX - PAN_STEP);
-        forest.viewportX = viewportX;
-        renderForest(forest);
+
+      // Panel keybindings (when panel is open)
+      if (diffPanel) {
+        if (key === "\x1b" || key === "\x1b\x1b") {
+          diffPanel = null;
+          needsRedraw = true;
+          clearScreen();
+          redraw();
+          return;
+        }
+        if (key === "j" || key === "\x1b[B") {
+          diffPanel.currentHunk = Math.min(diffPanel.currentHunk + 1, diffPanel.hunks.length - 1);
+          needsRedraw = true;
+          redraw();
+          return;
+        }
+        if (key === "k" || key === "\x1b[A") {
+          diffPanel.currentHunk = Math.max(diffPanel.currentHunk - 1, 0);
+          needsRedraw = true;
+          redraw();
+          return;
+        }
+        if (key === "a") {
+          diffPanel.hunkStatus[diffPanel.currentHunk] = "accepted";
+          const next = diffPanel.hunkStatus.findIndex((s, i) => i > diffPanel.currentHunk && s === "pending");
+          if (next >= 0) diffPanel.currentHunk = next;
+          checkAllResolved();
+          needsRedraw = true;
+          redraw();
+          return;
+        }
+        if (key === "r") {
+          diffPanel.hunkStatus[diffPanel.currentHunk] = "rejected";
+          const next = diffPanel.hunkStatus.findIndex((s, i) => i > diffPanel.currentHunk && s === "pending");
+          if (next >= 0) diffPanel.currentHunk = next;
+          checkAllResolved();
+          needsRedraw = true;
+          redraw();
+          return;
+        }
+        if (key === "A") {
+          for (let i = 0; i < diffPanel.hunkStatus.length; i++) {
+            if (diffPanel.hunkStatus[i] === "pending") diffPanel.hunkStatus[i] = "accepted";
+          }
+          checkAllResolved();
+          needsRedraw = true;
+          redraw();
+          return;
+        }
+        if (key === "R") {
+          for (let i = 0; i < diffPanel.hunkStatus.length; i++) {
+            if (diffPanel.hunkStatus[i] === "pending") diffPanel.hunkStatus[i] = "rejected";
+          }
+          checkAllResolved();
+          needsRedraw = true;
+          redraw();
+          return;
+        }
         return;
       }
-      // Right arrow: \x1b[C
-      if (key === "\x1b[C") {
-        viewportX = clampViewport(viewportX + PAN_STEP);
-        forest.viewportX = viewportX;
-        renderForest(forest);
+
+      if (key === "d") {
+        diffMode = !diffMode;
+        needsRedraw = true;
+        redraw();
         return;
       }
-    });
-  }
 
-  // Check for changes — used by both fs.watch and polling fallback
-  async function checkForUpdates() {
-    if (animating) return;
-
-    if (ignoreNextChange) {
-      ignoreNextChange = false;
-      return;
-    }
+      if (key === "r") {
+        process.stdout.write("\x1b[H");
+        process.stdout.write("Rescanning...");
+        const newFiles = scanCodebase(dir);
+        files.length = 0;
+        files.push(...newFiles);
+        regeneratePoints();
+        needsRedraw = true;
+        clearScreen();
+        redraw();
+        return;
+      }
 
-    const updated = readForest();
-    if (!updated) return;
+      if (key === "\x1b[D") {
+        camera.azimuth = clampAzimuth(camera.azimuth - 5);
+        needsRedraw = true;
+        redraw();
+        return;
+      }
+      if (key === "\x1b[C") {
+        camera.azimuth = clampAzimuth(camera.azimuth + 5);
+        needsRedraw = true;
+        redraw();
+        return;
+      }
+      if (key === "\x1b[A") {
+        camera.elevation = clampElevation(camera.elevation + 5);
+        needsRedraw = true;
+        redraw();
+        return;
+      }
+      if (key === "\x1b[B") {
+        camera.elevation = clampElevation(camera.elevation - 5);
+        needsRedraw = true;
+        redraw();
+        return;
+      }
 
-    // Only re-render if something actually changed
-    if (updated.totalPrompts === lastTotalPrompts) return;
+      if (key === "+" || key === "=") {
+        camera.distance = Math.max(10, camera.distance - 5);
+        needsRedraw = true;
+        redraw();
+        return;
+      }
+      if (key === "-" || key === "_") {
+        camera.distance = Math.min(120, camera.distance + 5);
+        needsRedraw = true;
+        redraw();
+        return;
+      }
 
-    const nextMaxId = updated.trees.reduce((max, tree) => Math.max(max, tree.id), 0);
-    forest = updated;
-    lastTotalPrompts = forest.totalPrompts;
+      const mouse = parseMouseEvent(data);
+      if (!mouse) return;
 
-    if (nextMaxId > lastMaxId) {
-      lastMaxId = nextMaxId;
-      // Center viewport on the new tree
-      const newTree = forest.trees.find((t) => t.id === nextMaxId);
-      if (newTree) {
-        const termWidth = getViewportWidth();
-        viewportX = clampViewport(newTree.x - Math.floor(termWidth / 2));
+      if (mouse.button === 0 && !mouse.released) {
+        mouseDown = true;
+        lastMouseX = mouse.x;
+        lastMouseY = mouse.y;
+        return;
       }
-      animating = true;
-      await animateNewTree(forest, nextMaxId);
-      animating = false;
-    } else {
-      renderForest(forest);
-    }
-  }
 
-  // fs.watch can drop events on macOS after atomic renames, so
-  // use it for fast response but also poll as a reliable fallback
-  function startWatcher() {
-    try {
-      const watcher = fs.watch(forestFile, () => {
-        checkForUpdates();
-      });
-      watcher.on("error", () => {});
-      return watcher;
-    } catch {
-      return null;
-    }
-  }
+      if (mouse.released && mouse.button === 0) {
+        const sy = mouse.y - 1;
+        const sx = mouse.x;
+        if (!diffPanel && currentBuf && sy >= 0 && sy < currentBuf.height && sx >= 0 && sx < currentBuf.width) {
+          const fi = currentBuf.fileIndices[sy][sx];
+          if (fi >= 0 && files[fi] && files[fi].changed) {
+            const filePath = filePaths[fi];
+            getFileDiff(dir, filePath).then((diff) => {
+              if (diff) {
+                const hunks = parseDiff(diff);
+                if (hunks.length > 0) {
+                  diffPanel = createDiffPanel(filePath, hunks);
+                  needsRedraw = true;
+                  clearScreen();
+                  redraw();
+                }
+              }
+            });
+            mouseDown = false;
+            return;
+          }
+        }
+        mouseDown = false;
+        return;
+      }
 
-  let watcher = startWatcher();
+      if (mouse.button === 32 && mouseDown) {
+        const dx = mouse.x - lastMouseX;
+        const dy = mouse.y - lastMouseY;
+        lastMouseX = mouse.x;
+        lastMouseY = mouse.y;
 
-  // Poll every 800ms as fallback — cheap since it only reads if mtime changed
-  let lastMtime = 0;
-  try {
-    lastMtime = fs.statSync(forestFile).mtimeMs;
-  } catch {}
+        camera.azimuth = clampAzimuth(camera.azimuth + dx * 0.8);
+        camera.elevation = clampElevation(camera.elevation - dy * 0.8);
+        needsRedraw = true;
+        redraw();
+        return;
+      }
 
-  setInterval(() => {
-    try {
-      const mtime = fs.statSync(forestFile).mtimeMs;
-      if (mtime !== lastMtime) {
-        lastMtime = mtime;
-        checkForUpdates();
-
-        // Re-establish watcher in case rename killed it
-        if (watcher) {
-          try { watcher.close(); } catch {}
+      if (mouse.button === 35 || (mouse.button >= 32 && mouse.released === false && !mouseDown)) {
+        const sy = mouse.y - 1;
+        const sx = mouse.x;
+        if (currentBuf && sy >= 0 && sy < currentBuf.height && sx >= 0 && sx < currentBuf.width) {
+          const fi = currentBuf.fileIndices[sy][sx];
+          const newHover = fi >= 0 ? filePaths[fi] : "";
+          const isModified = fi >= 0 && files[fi] && files[fi].changed;
+          if (newHover !== hoveredFile) {
+            hoveredFile = newHover;
+            hoveredModified = isModified;
+            writeAnsi(`\x1b[1;1H`);
+            process.stdout.write(renderTopBar(hoveredFile, screenWidth, hoveredModified));
+          }
         }
-        watcher = startWatcher();
       }
-    } catch {}
-  }, 800);
+    });
+  }
 }