ftreeview 0.1.1

package/dist/cli.js

@@ -0,0 +1,1619 @@
+#!/usr/bin/env node
+
+// src/cli.js
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "node:fs";
+import { resolve as resolve4, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { statSync as statSync3, readdirSync as readdirSync3 } from "node:fs";
+import { render } from "ink";
+import React5 from "react";
+
+// src/App.jsx
+import React4, { useEffect as useEffect5, useCallback as useCallback5, useMemo, useState as useState6, useRef as useRef5 } from "react";
+import { isAbsolute, relative as relative3, resolve as resolve3, sep as sep3 } from "node:path";
+import { Box as Box4 } from "ink";
+
+// src/components/TreeView.jsx
+import React2 from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/components/TreeLine.jsx
+import React from "react";
+import { Box, Text } from "ink";
+import { getIcon, detectFileType } from "../src/lib/icons.js";
+
+// src/lib/changeStatus.js
+var CHANGE_STATUS = {
+  ADDED: "A",
+  MODIFIED: "M"
+};
+function normalizeChangeStatus(status = "") {
+  if (status === CHANGE_STATUS.MODIFIED) {
+    return CHANGE_STATUS.MODIFIED;
+  }
+  if (status === CHANGE_STATUS.ADDED) {
+    return CHANGE_STATUS.ADDED;
+  }
+  return "";
+}
+function mergeChangeStatus(first = "", second = "") {
+  const left = normalizeChangeStatus(first);
+  const right = normalizeChangeStatus(second);
+  if (left === CHANGE_STATUS.MODIFIED || right === CHANGE_STATUS.MODIFIED) {
+    return CHANGE_STATUS.MODIFIED;
+  }
+  if (left === CHANGE_STATUS.ADDED || right === CHANGE_STATUS.ADDED) {
+    return CHANGE_STATUS.ADDED;
+  }
+  return "";
+}
+function mapGitStatusToChangeStatus(gitStatus = "") {
+  if (gitStatus === "U") {
+    return CHANGE_STATUS.ADDED;
+  }
+  return normalizeChangeStatus(gitStatus);
+}
+function mapWatcherEventToChangeStatus(event = "") {
+  if (event === "add" || event === "addDir") {
+    return CHANGE_STATUS.ADDED;
+  }
+  if (event === "change") {
+    return CHANGE_STATUS.MODIFIED;
+  }
+  return "";
+}
+
+// src/components/TreeLine.jsx
+import { getPrefix } from "../src/lib/connectors.js";
+
+// src/lib/theme.js
+var ICON_SET = {
+  AUTO: "auto",
+  EMOJI: "emoji",
+  NERD: "nerd",
+  ASCII: "ascii"
+};
+var THEME = {
+  VSCODE: "vscode"
+};
+var VSCODE_THEME = {
+  name: THEME.VSCODE,
+  colors: {
+    fg: "white",
+    muted: "gray",
+    accent: "cyan",
+    success: "green",
+    warning: "yellow",
+    danger: "red"
+  },
+  tree: {
+    connector: { color: "gray", dimColor: true },
+    cursor: { backgroundColor: "blue", color: "white" },
+    dirName: { color: "cyan", bold: true },
+    fileName: { color: "white" },
+    hidden: { color: "gray", dimColor: true },
+    symlink: { color: "magenta" },
+    error: { color: "red" }
+  },
+  statusBar: {
+    separator: "\u2022",
+    separatorStyle: { color: "gray", dimColor: true },
+    hintStyle: { color: "gray", dimColor: true }
+  }
+};
+function resolveIconSet({ cliIconSet, noIcons = false, env = process.env } = {}) {
+  const fromCli = (cliIconSet || "").toLowerCase();
+  const fromEnv = (env.FTREE_ICON_SET || "").toLowerCase();
+  if (noIcons && !fromCli) {
+    return ICON_SET.ASCII;
+  }
+  const requested = fromCli || fromEnv || ICON_SET.EMOJI;
+  if (requested === ICON_SET.NERD) return ICON_SET.NERD;
+  if (requested === ICON_SET.ASCII) return ICON_SET.ASCII;
+  return ICON_SET.EMOJI;
+}
+function resolveThemeName({ cliTheme, env = process.env } = {}) {
+  const requested = (cliTheme || env.FTREE_THEME || THEME.VSCODE).toLowerCase();
+  if (requested === THEME.VSCODE) {
+    return THEME.VSCODE;
+  }
+  return THEME.VSCODE;
+}
+function getTheme(themeName = THEME.VSCODE) {
+  if (themeName === THEME.VSCODE) {
+    return VSCODE_THEME;
+  }
+  return VSCODE_THEME;
+}
+
+// src/components/TreeLine.jsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function truncateFilename(name, maxWidth) {
+  if (maxWidth >= name.length) {
+    return name;
+  }
+  const endLength = Math.min(4, Math.floor(maxWidth / 2));
+  const startLength = maxWidth - endLength - 1;
+  if (startLength <= 0) {
+    return "\u2026" + name.slice(Math.max(0, name.length - maxWidth + 1));
+  }
+  return name.slice(0, startLength) + "\u2026" + name.slice(name.length - endLength);
+}
+function getGitBadgeColor(status) {
+  const colorMap = {
+    "M": "yellow",
+    "A": "green",
+    "D": "red",
+    "U": "green",
+    "R": "cyan"
+  };
+  return colorMap[status] || "white";
+}
+function getChangeIndicator(status) {
+  const normalizedStatus = normalizeChangeStatus(status);
+  if (normalizedStatus === "M") {
+    return { icon: "\u25CF", color: "yellow" };
+  }
+  if (normalizedStatus === "A") {
+    return { icon: "\u271A", color: "green" };
+  }
+  return null;
+}
+function TreeLine({
+  node,
+  isLast = false,
+  ancestorIsLast = [],
+  isCursor = false,
+  termWidth = 80,
+  iconSet = "emoji",
+  theme = VSCODE_THEME,
+  gitStatus = "",
+  changeStatus = ""
+}) {
+  const finalTheme = theme || VSCODE_THEME;
+  const prefix = getPrefix(node, isLast, ancestorIsLast);
+  const fileType = detectFileType(node.mode);
+  const icon = getIcon(
+    node.name,
+    node.isDir,
+    node.expanded,
+    node.isSymlink,
+    node.hasError,
+    fileType,
+    { iconSet }
+  );
+  const changeIndicator = getChangeIndicator(changeStatus);
+  const baseNameStyle = (() => {
+    if (node.hasError) return finalTheme.tree.error;
+    if (node.isSymlink) return finalTheme.tree.symlink;
+    if (node.name?.startsWith(".")) return finalTheme.tree.hidden;
+    if (node.isDir) return finalTheme.tree.dirName;
+    return finalTheme.tree.fileName;
+  })();
+  const cursorStyle = isCursor ? finalTheme.tree.cursor : null;
+  const badgeCursorStyle = cursorStyle?.backgroundColor ? { backgroundColor: cursorStyle.backgroundColor } : null;
+  const connectorStyle = finalTheme.tree.connector;
+  const iconWidth = icon ? 2 : 0;
+  const changeIndicatorWidth = changeIndicator ? 3 : 0;
+  const gitBadgeWidth = gitStatus ? 3 : 0;
+  const reservedWidth = prefix.length + iconWidth + changeIndicatorWidth + gitBadgeWidth + 2;
+  const maxFilenameWidth = Math.max(4, termWidth - reservedWidth);
+  const displayName = truncateFilename(node.name, maxFilenameWidth);
+  const mainContent = /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Text, { ...connectorStyle, ...cursorStyle || {}, children: prefix }),
+    icon && /* @__PURE__ */ jsxs(Text, { ...cursorStyle || {}, children: [
+      icon,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx(
+      Text,
+      {
+        ...baseNameStyle,
+        ...cursorStyle || {},
+        children: displayName
+      }
+    )
+  ] });
+  if (gitStatus || changeIndicator) {
+    return /* @__PURE__ */ jsxs(Box, { justifyContent: "spaceBetween", width: termWidth, children: [
+      mainContent,
+      /* @__PURE__ */ jsxs(Box, { children: [
+        gitStatus && /* @__PURE__ */ jsxs(Text, { color: getGitBadgeColor(gitStatus), ...badgeCursorStyle || {}, children: [
+          " ",
+          gitStatus,
+          " "
+        ] }),
+        changeIndicator && /* @__PURE__ */ jsxs(Text, { color: changeIndicator.color, ...badgeCursorStyle || {}, children: [
+          " ",
+          changeIndicator.icon,
+          " "
+        ] })
+      ] })
+    ] });
+  }
+  return mainContent;
+}
+
+// src/components/TreeView.jsx
+import { computeAncestorPrefixes } from "../src/lib/connectors.js";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function isLastChild(flatList, index) {
+  if (index >= flatList.length - 1) {
+    return true;
+  }
+  const currentNode = flatList[index];
+  const nextNode = flatList[index + 1];
+  return nextNode.depth <= currentNode.depth;
+}
+function EmptyDirectory() {
+  return /* @__PURE__ */ jsx2(Box2, { justifyContent: "center", paddingY: 1, children: /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "(empty directory)" }) });
+}
+function TreeView({
+  flatList = [],
+  cursor = 0,
+  viewportStart = 0,
+  viewportHeight = 20,
+  termWidth = 80,
+  iconSet = "emoji",
+  theme = null
+}) {
+  if (flatList.length === 0) {
+    return /* @__PURE__ */ jsx2(EmptyDirectory, {});
+  }
+  const safeViewportStart = Math.max(0, Math.min(viewportStart, flatList.length - 1));
+  const safeViewportHeight = Math.min(viewportHeight, flatList.length - safeViewportStart);
+  const visibleNodes = flatList.slice(safeViewportStart, safeViewportStart + safeViewportHeight);
+  if (process.env.FTREE_DEBUG) {
+    console.log(`[DEBUG] TreeView rendering: flatList.length=${flatList.length}, viewportHeight=${viewportHeight}`);
+    console.log(`[DEBUG] TreeView: safeViewportStart=${safeViewportStart}, safeViewportHeight=${safeViewportHeight}`);
+    console.log(`[DEBUG] TreeView: visibleNodes count=${visibleNodes.length}`);
+  }
+  return /* @__PURE__ */ jsx2(Box2, { flexDirection: "column", width: termWidth, children: visibleNodes.map((node, visibleIndex) => {
+    const actualIndex = safeViewportStart + visibleIndex;
+    const isLast = isLastChild(flatList, actualIndex);
+    const ancestorIsLast = computeAncestorPrefixes(flatList, actualIndex);
+    const isCursor = actualIndex === cursor;
+    return /* @__PURE__ */ jsx2(
+      TreeLine,
+      {
+        node,
+        isLast,
+        ancestorIsLast,
+        isCursor,
+        termWidth,
+        iconSet,
+        theme,
+        gitStatus: node.gitStatus || "",
+        changeStatus: node.changeStatus || ""
+      },
+      node.path
+    );
+  }) });
+}
+var TreeView_default = TreeView;
+
+// src/components/StatusBar.jsx
+import React3 from "react";
+import { Box as Box3, Text as Text3 } from "ink";
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function truncatePath(path, maxWidth) {
+  if (maxWidth >= path.length) {
+    return path;
+  }
+  const endLength = Math.min(15, maxWidth - 3);
+  const startLength = Math.max(3, maxWidth - endLength - 3);
+  if (startLength + endLength + 3 > maxWidth) {
+    return "..." + path.slice(Math.max(0, path.length - maxWidth + 3));
+  }
+  return path.slice(0, startLength) + "..." + path.slice(path.length - endLength);
+}
+function formatPath(path, maxWidth) {
+  const segments = path.split("/");
+  const segmentCount = segments.length;
+  if (path.length <= maxWidth || segmentCount <= 3) {
+    return truncatePath(path, maxWidth);
+  }
+  const first = segments[0];
+  const lastTwo = segments.slice(-2).join("/");
+  const ellipsisPath = `${first}/.../${lastTwo}`;
+  if (ellipsisPath.length <= maxWidth) {
+    return ellipsisPath;
+  }
+  return truncatePath(ellipsisPath, maxWidth);
+}
+function calculateGitStatus(statusMap) {
+  if (!statusMap || statusMap.size === 0) {
+    return { isRepo: false, summary: "" };
+  }
+  const counts = { M: 0, A: 0, D: 0, U: 0, R: 0 };
+  for (const status of statusMap.values()) {
+    if (counts.hasOwnProperty(status)) {
+      counts[status]++;
+    }
+  }
+  const parts = [];
+  if (counts.D) parts.push(`${counts.D}D`);
+  if (counts.M) parts.push(`${counts.M}M`);
+  if (counts.A) parts.push(`${counts.A}A`);
+  if (counts.U) parts.push(`${counts.U}U`);
+  if (counts.R) parts.push(`${counts.R}R`);
+  const summary = parts.length > 0 ? parts.join(" ") : "clean";
+  return { isRepo: true, summary };
+}
+function StatusBar({
+  version: version2 = "v0.1.0",
+  rootPath = ".",
+  fileCount = 0,
+  dirCount = 0,
+  isWatching = false,
+  gitEnabled = false,
+  isGitRepo = false,
+  gitSummary = "",
+  showHelp = true,
+  termWidth = 80,
+  iconSet = "emoji",
+  theme = VSCODE_THEME
+}) {
+  const finalTheme = theme || VSCODE_THEME;
+  const barIcons = (() => {
+    if (iconSet === "nerd") {
+      return {
+        file: "\uF15B",
+        folder: "\uE5FF",
+        watch: "\uF06E",
+        git: "\uE702"
+      };
+    }
+    if (iconSet === "ascii") {
+      return {
+        file: "F",
+        folder: "D",
+        watch: "W",
+        git: "git"
+      };
+    }
+    return {
+      file: "\u{1F4C4}",
+      folder: "\u{1F4C1}",
+      watch: "\u{1F441}",
+      git: "\u{1F33F}"
+    };
+  })();
+  const sep4 = ` ${finalTheme.statusBar.separator} `;
+  const paddingWidth = 2;
+  const versionText = `ftree ${version2}`;
+  const countsText = `${barIcons.file} ${fileCount}  ${barIcons.folder} ${dirCount}`;
+  const watchText = `${barIcons.watch} ${isWatching ? "Watching" : "Static"}`;
+  const gitText = gitEnabled && isGitRepo ? `${barIcons.git} ${gitSummary || "clean"}` : "";
+  const fixedSegments = [versionText, countsText, watchText].concat(gitText ? [gitText] : []);
+  const fixedWidth = fixedSegments.reduce((sum, part) => sum + part.length, 0) + fixedSegments.length * sep4.length + paddingWidth;
+  const pathMaxWidth = Math.max(8, termWidth - fixedWidth);
+  const displayPath = formatPath(rootPath, pathMaxWidth);
+  return /* @__PURE__ */ jsxs2(Box3, { flexDirection: "column", width: termWidth, children: [
+    /* @__PURE__ */ jsxs2(
+      Box3,
+      {
+        width: termWidth,
+        paddingX: 1,
+        children: [
+          /* @__PURE__ */ jsx3(Text3, { color: finalTheme.colors.accent, bold: true, children: "ftree" }),
+          /* @__PURE__ */ jsxs2(Text3, { color: finalTheme.colors.muted, dimColor: true, children: [
+            " ",
+            version2
+          ] }),
+          /* @__PURE__ */ jsx3(Text3, { ...finalTheme.statusBar.separatorStyle, children: sep4 }),
+          /* @__PURE__ */ jsx3(Text3, { color: finalTheme.colors.fg, bold: true, children: displayPath }),
+          /* @__PURE__ */ jsx3(Text3, { ...finalTheme.statusBar.separatorStyle, children: sep4 }),
+          /* @__PURE__ */ jsx3(Text3, { color: finalTheme.colors.muted, children: countsText }),
+          /* @__PURE__ */ jsx3(Text3, { ...finalTheme.statusBar.separatorStyle, children: sep4 }),
+          /* @__PURE__ */ jsx3(Text3, { color: isWatching ? finalTheme.colors.success : finalTheme.colors.muted, children: watchText }),
+          gitEnabled && isGitRepo && /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsx3(Text3, { ...finalTheme.statusBar.separatorStyle, children: sep4 }),
+            /* @__PURE__ */ jsx3(Text3, { color: gitSummary === "clean" ? finalTheme.colors.success : finalTheme.colors.warning, children: gitText })
+          ] })
+        ]
+      }
+    ),
+    showHelp && /* @__PURE__ */ jsx3(
+      Box3,
+      {
+        width: termWidth,
+        paddingX: 1,
+        children: /* @__PURE__ */ jsx3(Text3, { ...finalTheme.statusBar.hintStyle, children: "q quit  \u2191\u2193/jk move  \u2190\u2192/hl expand  space toggle  r refresh" })
+      }
+    )
+  ] });
+}
+function calculateCounts(flatList = []) {
+  let fileCount = 0;
+  let dirCount = 0;
+  for (const node of flatList) {
+    if (node.depth > 0 && node.isDir) {
+      dirCount++;
+    } else if (node.depth > 0) {
+      fileCount++;
+    }
+  }
+  return { fileCount, dirCount };
+}
+var StatusBar_default = StatusBar;
+
+// src/hooks/useTree.js
+import { readdirSync as readdirSync2, statSync as statSync2, lstatSync, readlinkSync } from "node:fs";
+import { resolve as resolve2, basename, relative as relative2, sep as sep2 } from "node:path";
+import { useState, useCallback, useRef } from "react";
+
+// src/lib/constants.js
+var DEFAULT_CONFIG = {
+  /** Maximum depth to traverse the directory tree */
+  maxDepth: 10,
+  /** Show hidden files (starting with .) */
+  showHidden: false,
+  /** Show ignored files (--no-ignore flag) */
+  showIgnored: false,
+  /** Files/directories to ignore (gitignore-style patterns) */
+  ignorePatterns: [
+    "node_modules/**",
+    ".git/**",
+    "dist/**",
+    "build/**",
+    "*.log"
+  ],
+  /** Watch for file system changes and update tree */
+  watch: true,
+  /** Show git status (modified, added, deleted, untracked files) */
+  showGitStatus: true,
+  /** Number of concurrent file system operations */
+  concurrency: 50,
+  /** Update interval for git status (ms) */
+  gitStatusInterval: 2e3,
+  /** Debounce delay for file system events (ms) */
+  debounceDelay: 100
+};
+
+// src/hooks/useIgnore.js
+import { existsSync, readdirSync, statSync, readFileSync } from "node:fs";
+import { resolve, join, relative, sep } from "node:path";
+import ignore from "ignore";
+var DEFAULT_PATTERNS = [
+  ".git",
+  ".git/",
+  ".git/**",
+  "node_modules",
+  "node_modules/"
+];
+function findGitignoreFiles(rootPath) {
+  const gitignoreMap = /* @__PURE__ */ new Map();
+  function scanDirectory(dirPath) {
+    try {
+      const entries = readdirSync(dirPath, { withFileTypes: true });
+      const gitignorePath = join(dirPath, ".gitignore");
+      if (existsSync(gitignorePath)) {
+        gitignoreMap.set(dirPath, gitignorePath);
+      }
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== ".git") {
+          const subPath = join(dirPath, entry.name);
+          scanDirectory(subPath);
+        }
+      }
+    } catch (error) {
+    }
+  }
+  scanDirectory(rootPath);
+  return gitignoreMap;
+}
+function createIgnoreFilter(rootPath, options = {}) {
+  const { showIgnored = false, extraIgnorePatterns = [] } = options;
+  if (showIgnored) {
+    return {
+      shouldIgnore: (relativePath) => false,
+      addPattern: () => {
+      },
+      filter: (paths) => paths
+    };
+  }
+  const ig = ignore();
+  for (const pattern of DEFAULT_PATTERNS) {
+    ig.add(pattern);
+  }
+  if (extraIgnorePatterns.length > 0) {
+    ig.add(extraIgnorePatterns);
+  }
+  const gitignoreMap = findGitignoreFiles(rootPath);
+  const loadedIgnores = /* @__PURE__ */ new Set();
+  function loadPatternsForDirectory(dirAbsPath) {
+    if (loadedIgnores.has(dirAbsPath)) {
+      return;
+    }
+    const gitignorePath = gitignoreMap.get(dirAbsPath);
+    if (gitignorePath && existsSync(gitignorePath)) {
+      try {
+        const content = readFileSync(gitignorePath, "utf-8");
+        ig.add(content);
+        loadedIgnores.add(dirAbsPath);
+      } catch (error) {
+      }
+    }
+  }
+  function shouldIgnore(relativePath) {
+    if (relativePath === "") {
+      return false;
+    }
+    const normalizedPath = relativePath.split(sep).join("/");
+    return ig.ignores(normalizedPath);
+  }
+  function filter(paths) {
+    return ig.filter(paths);
+  }
+  function addPattern(pattern) {
+    ig.add(pattern);
+  }
+  return {
+    shouldIgnore,
+    filter,
+    addPattern,
+    loadPatternsForDirectory
+  };
+}
+
+// src/hooks/useTree.js
+function createFileNode(absPath, rootPath, depth, isDir, isSymlink = false) {
+  let stats;
+  let targetPath = null;
+  let hasError = false;
+  let error = null;
+  try {
+    stats = isSymlink ? lstatSync(absPath) : statSync2(absPath);
+    if (isSymlink) {
+      try {
+        targetPath = readlinkSync(absPath);
+      } catch (e) {
+        hasError = true;
+        error = "Cannot read symlink";
+      }
+    }
+  } catch (e) {
+    if (e.code === "EACCES" || e.code === "EPERM") {
+      return {
+        name: basename(absPath),
+        path: relative2(rootPath, absPath).split(sep2).join("/"),
+        absPath,
+        isDir,
+        children: null,
+        expanded: false,
+        depth,
+        size: 0,
+        mode: 0,
+        gitStatus: "",
+        changeStatus: "",
+        hasError: true,
+        error: "Permission denied"
+      };
+    }
+    throw e;
+  }
+  return {
+    name: basename(absPath),
+    path: relative2(rootPath, absPath).split(sep2).join("/"),
+    absPath,
+    isDir,
+    children: isDir ? [] : null,
+    expanded: false,
+    depth,
+    size: stats.size,
+    mode: stats.mode,
+    gitStatus: "",
+    // Will be populated by git status hook (T10)
+    changeStatus: "",
+    // Combined A/M indicator from git + watcher states
+    isSymlink,
+    targetPath,
+    hasError,
+    error
+  };
+}
+function compareNodes(a, b) {
+  if (a.isDir && !b.isDir) return -1;
+  if (!a.isDir && b.isDir) return 1;
+  return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+}
+function buildTree(rootPath, options = {}, currentDepth = 0, ignoreFilter = null, baseRootPath = null) {
+  const { depth = DEFAULT_CONFIG.maxDepth, showHidden = false } = options;
+  const finalBaseRootPath = baseRootPath || rootPath;
+  if (ignoreFilter === null) {
+    ignoreFilter = createIgnoreFilter(finalBaseRootPath, options);
+  }
+  const rootNode = createFileNode(rootPath, finalBaseRootPath, currentDepth, true, false);
+  rootNode.expanded = true;
+  if (currentDepth >= depth) {
+    return rootNode;
+  }
+  try {
+    if (ignoreFilter.loadPatternsForDirectory) {
+      ignoreFilter.loadPatternsForDirectory(rootPath);
+    }
+    const entries = readdirSync2(rootPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryName = entry.name;
+      const entryAbsPath = resolve2(rootPath, entryName);
+      if (entryName === ".git") {
+        continue;
+      }
+      if (!showHidden && entryName.startsWith(".")) {
+        continue;
+      }
+      const isDir = entry.isDirectory();
+      const isSymlink = entry.isSymbolicLink();
+      const entryRelativePath = relative2(finalBaseRootPath, entryAbsPath);
+      if (ignoreFilter.shouldIgnore(entryRelativePath)) {
+        continue;
+      }
+      let childNode;
+      try {
+        childNode = createFileNode(
+          entryAbsPath,
+          finalBaseRootPath,
+          currentDepth + 1,
+          isDir,
+          isSymlink
+        );
+      } catch (e) {
+        if (e.code === "EACCES" || e.code === "EPERM") {
+          childNode = {
+            name: entryName,
+            path: relative2(finalBaseRootPath, entryAbsPath).split(sep2).join("/"),
+            absPath: entryAbsPath,
+            isDir,
+            children: null,
+            expanded: false,
+            depth: currentDepth + 1,
+            size: 0,
+            mode: 0,
+            gitStatus: "",
+            changeStatus: "",
+            hasError: true,
+            error: "Permission denied",
+            isSymlink,
+            targetPath: null
+          };
+        } else {
+          continue;
+        }
+      }
+      if (isDir && !isSymlink) {
+        const childOptions = { ...options, showHidden };
+        const subtree = buildTree(
+          entryAbsPath,
+          childOptions,
+          currentDepth + 1,
+          ignoreFilter,
+          finalBaseRootPath
+        );
+        childNode.children = subtree.children;
+      }
+      rootNode.children.push(childNode);
+    }
+    rootNode.children.sort(compareNodes);
+  } catch (error) {
+    if (error.code === "EACCES" || error.code === "EPERM") {
+      rootNode.hasError = true;
+      rootNode.error = "Permission denied";
+      rootNode.children = [];
+    } else {
+      rootNode.children = [];
+    }
+  }
+  return rootNode;
+}
+function flattenTree(root) {
+  const result = [];
+  function traverse(node) {
+    result.push(node);
+    if (node.expanded && node.children && node.children.length > 0) {
+      for (const child of node.children) {
+        traverse(child);
+      }
+    }
+  }
+  traverse(root);
+  return result;
+}
+function applyGitStatus(root, statusMap) {
+  function walk(node) {
+    if (!node.isDir) {
+      node.gitStatus = statusMap.get(node.path) || "";
+    } else {
+      let aggregatedStatus = "";
+      for (const child of node.children) {
+        walk(child);
+        const childStatus = child.gitStatus;
+        if (childStatus === "D") {
+          aggregatedStatus = "D";
+        } else if (childStatus === "M" && aggregatedStatus !== "D") {
+          aggregatedStatus = "M";
+        } else if (childStatus === "A" && aggregatedStatus !== "D" && aggregatedStatus !== "M") {
+          aggregatedStatus = "A";
+        } else if (childStatus === "U" && !aggregatedStatus) {
+          aggregatedStatus = "U";
+        } else if (childStatus === "R" && !aggregatedStatus) {
+          aggregatedStatus = "R";
+        }
+      }
+      node.gitStatus = aggregatedStatus;
+    }
+  }
+  walk(root);
+  return root;
+}
+function applyChangeIndicators(root, gitStatusMap = /* @__PURE__ */ new Map(), watcherStatusMap = /* @__PURE__ */ new Map()) {
+  function walk(node) {
+    if (!node.isDir) {
+      const gitChangeStatus = mapGitStatusToChangeStatus(
+        gitStatusMap.get(node.path) || node.gitStatus || ""
+      );
+      const watcherChangeStatus = normalizeChangeStatus(
+        watcherStatusMap.get(node.path) || ""
+      );
+      const fileChangeStatus = mergeChangeStatus(gitChangeStatus, watcherChangeStatus);
+      node.changeStatus = fileChangeStatus;
+      return fileChangeStatus;
+    }
+    let aggregatedStatus = normalizeChangeStatus(watcherStatusMap.get(node.path) || "");
+    if (node.children && node.children.length > 0) {
+      for (const child of node.children) {
+        const childStatus = walk(child);
+        aggregatedStatus = mergeChangeStatus(aggregatedStatus, childStatus);
+      }
+    }
+    const finalStatus = node.depth === 0 ? "" : aggregatedStatus;
+    node.changeStatus = finalStatus;
+    return finalStatus;
+  }
+  walk(root);
+  return root;
+}
+function mergeExpandState(oldTree, newTree) {
+  if (!oldTree || !newTree) return newTree;
+  const expandedPaths = /* @__PURE__ */ new Set();
+  function collectExpanded(node) {
+    if (node.isDir && node.expanded) {
+      expandedPaths.add(node.path);
+    }
+    if (node.children) {
+      for (const child of node.children) {
+        collectExpanded(child);
+      }
+    }
+  }
+  collectExpanded(oldTree);
+  function applyExpanded(node) {
+    if (node.isDir && expandedPaths.has(node.path)) {
+      node.expanded = true;
+    }
+    if (node.children) {
+      for (const child of node.children) {
+        applyExpanded(child);
+      }
+    }
+  }
+  applyExpanded(newTree);
+  return newTree;
+}
+function useTree(rootPath, options = {}) {
+  const absPath = resolve2(rootPath);
+  const [tree, setTree] = useState(() => buildTree(absPath, options));
+  const treeRef = useRef(tree);
+  treeRef.current = tree;
+  const [flatList, setFlatList] = useState(() => flattenTree(tree));
+  const refreshFlatList = useCallback(() => {
+    const currentTree = treeRef.current;
+    if (!currentTree) {
+      return;
+    }
+    setFlatList(flattenTree(currentTree));
+  }, []);
+  const rebuildTree = useCallback((preserveState = true) => {
+    const oldTree = treeRef.current;
+    const newTree = buildTree(absPath, options);
+    const mergedTree = preserveState && oldTree ? mergeExpandState(oldTree, newTree) : newTree;
+    if (process.env.FTREE_DEBUG) {
+      const flat = flattenTree(mergedTree);
+      console.log(`[DEBUG] rebuildTree: BEFORE setTree, flatList has ${flat.length} items`);
+      console.log(`[DEBUG] rebuildTree: root has ${mergedTree.children?.length || 0} direct children`);
+      console.log(`[DEBUG] rebuildTree: newTree root has ${newTree.children?.length || 0} direct children`);
+    }
+    setTree(mergedTree);
+    setFlatList(flattenTree(mergedTree));
+    if (process.env.FTREE_DEBUG) {
+      console.log(`[DEBUG] rebuildTree: AFTER setTree/setFlatList, flatList state updated`);
+    }
+  }, [absPath, options]);
+  const getTree = useCallback(() => treeRef.current, []);
+  return {
+    tree,
+    flatList,
+    refreshFlatList,
+    rebuildTree,
+    getTree
+  };
+}
+
+// src/hooks/useNavigation.js
+import { useState as useState2, useEffect, useCallback as useCallback2 } from "react";
+import { useInput, useApp } from "ink";
+var VIEWPORT_MARGIN = 3;
+function useNavigation(flatList = [], rebuildTree, refreshFlatList = null) {
+  const { exit } = useApp();
+  const viewportHeight = process.stdout.rows - 2;
+  const [cursor, setCursor] = useState2(0);
+  const [viewportStart, setViewportStart] = useState2(0);
+  const refreshVisibleTree = useCallback2(() => {
+    if (typeof refreshFlatList === "function") {
+      refreshFlatList();
+      return;
+    }
+    rebuildTree(true);
+  }, [refreshFlatList, rebuildTree]);
+  const setCursorByPath = useCallback2((path) => {
+    if (!path || flatList.length === 0) return -1;
+    const newIndex = flatList.findIndex((node) => node.path === path);
+    if (newIndex !== -1) {
+      setCursor(newIndex);
+      return newIndex;
+    }
+    return -1;
+  }, [flatList]);
+  const findParentIndex = useCallback2((currentIndex) => {
+    if (currentIndex <= 0) return null;
+    const currentDepth = flatList[currentIndex]?.depth ?? 0;
+    for (let i = currentIndex - 1; i >= 0; i--) {
+      if (flatList[i]?.depth < currentDepth) {
+        return i;
+      }
+    }
+    return null;
+  }, [flatList]);
+  const moveUp = useCallback2(() => {
+    setCursor((prev) => Math.max(0, prev - 1));
+  }, []);
+  const moveDown = useCallback2(() => {
+    setCursor((prev) => Math.min(flatList.length - 1, prev + 1));
+  }, [flatList.length]);
+  const expand = useCallback2(() => {
+    if (flatList.length === 0) return;
+    const node = flatList[cursor];
+    if (!node) return;
+    if (node.isDir && !node.expanded) {
+      node.expanded = true;
+      refreshVisibleTree();
+    }
+  }, [cursor, flatList, refreshVisibleTree]);
+  const smartCollapse = useCallback2(() => {
+    if (flatList.length === 0) return;
+    const node = flatList[cursor];
+    if (!node) return;
+    if (node.expanded && node.isDir) {
+      node.expanded = false;
+      refreshVisibleTree();
+    } else {
+      const parentIndex = findParentIndex(cursor);
+      if (parentIndex !== null) {
+        setCursor(parentIndex);
+      }
+    }
+  }, [cursor, flatList, refreshVisibleTree, findParentIndex]);
+  const toggle = useCallback2(() => {
+    if (flatList.length === 0) return;
+    const node = flatList[cursor];
+    if (!node || !node.isDir) return;
+    node.expanded = !node.expanded;
+    refreshVisibleTree();
+  }, [cursor, flatList, refreshVisibleTree]);
+  const jumpToTop = useCallback2(() => {
+    setCursor(0);
+  }, []);
+  const jumpToBottom = useCallback2(() => {
+    setCursor(Math.max(0, flatList.length - 1));
+  }, [flatList.length]);
+  const refresh = useCallback2(() => {
+    rebuildTree(true);
+  }, [rebuildTree]);
+  useInput((input, key) => {
+    if (key.upArrow || input === "k") {
+      moveUp();
+    } else if (key.downArrow || input === "j") {
+      moveDown();
+    } else if (key.rightArrow || input === "l" || key.return) {
+      expand();
+    } else if (key.leftArrow || input === "h") {
+      smartCollapse();
+    } else if (key.ctrl && input === "c") {
+      exit();
+    } else if (input === "q") {
+      exit();
+    } else if (input === " ") {
+      toggle();
+    } else if (input === "g") {
+      jumpToTop();
+    } else if (input === "G") {
+      jumpToBottom();
+    } else if (input === "r") {
+      refresh();
+    }
+  });
+  useEffect(() => {
+    if (flatList.length === 0) {
+      setViewportStart(0);
+      return;
+    }
+    if (cursor < viewportStart) {
+      setViewportStart(cursor);
+    } else if (cursor >= viewportStart + viewportHeight) {
+      setViewportStart(cursor - viewportHeight + 1);
+    }
+    if (cursor - viewportStart < VIEWPORT_MARGIN && viewportStart > 0) {
+      setViewportStart(Math.max(0, cursor - VIEWPORT_MARGIN));
+    } else if (viewportStart + viewportHeight - cursor < VIEWPORT_MARGIN) {
+      const maxStart = Math.max(0, flatList.length - viewportHeight);
+      setViewportStart(Math.min(maxStart, cursor - viewportHeight + VIEWPORT_MARGIN + 1));
+    }
+  }, [cursor, flatList.length, viewportHeight]);
+  useEffect(() => {
+    if (flatList.length === 0) {
+      setCursor(0);
+      setViewportStart(0);
+    }
+  }, [flatList.length]);
+  return {
+    cursor,
+    viewportStart,
+    exit,
+    setCursorByPath,
+    setCursor
+  };
+}
+
+// src/hooks/useGitStatus.js
+import { execFile } from "node:child_process";
+import { useEffect as useEffect2, useState as useState3, useCallback as useCallback3, useRef as useRef2 } from "react";
+function parsePorcelain(output) {
+  const statusMap = /* @__PURE__ */ new Map();
+  const lines = output.split("\n").filter(Boolean);
+  for (const line of lines) {
+    if (line.startsWith("!!")) {
+      continue;
+    }
+    const stagedStatus = line[0];
+    const unstagedStatus = line[1];
+    let filePath;
+    if (line[2] === '"') {
+      const endQuote = line.indexOf('"', 3);
+      filePath = line.slice(3, endQuote);
+    } else {
+      filePath = line.slice(3);
+    }
+    let statusCode = "";
+    if (stagedStatus === "R") {
+      statusCode = "R";
+      if (filePath.includes(" -> ")) {
+        filePath = filePath.split(" -> ")[1];
+      }
+    } else if (stagedStatus === "D" || unstagedStatus === "D") {
+      statusCode = "D";
+    } else if (stagedStatus === "A") {
+      statusCode = "A";
+    } else if (stagedStatus === "M" || unstagedStatus === "M") {
+      statusCode = "M";
+    } else if (stagedStatus === "?" && unstagedStatus === "?") {
+      statusCode = "U";
+    } else if (stagedStatus === "D" && unstagedStatus === "D" || stagedStatus === "A" && unstagedStatus === "A" || (stagedStatus === "U" || unstagedStatus === "U")) {
+      statusCode = "C";
+    }
+    if (statusCode) {
+      if (filePath.endsWith("/") || filePath.endsWith("\\")) {
+        filePath = filePath.slice(0, -1);
+      }
+      const normalizedPath = filePath.replace(/\\/g, "/");
+      statusMap.set(normalizedPath, statusCode);
+    }
+  }
+  return statusMap;
+}
+function areStatusMapsEqual(first, second) {
+  if (first === second) return true;
+  if (!first || !second) return false;
+  if (first.size !== second.size) return false;
+  for (const [path, status] of first.entries()) {
+    if (second.get(path) !== status) {
+      return false;
+    }
+  }
+  return true;
+}
+function getGitStatus(rootPath) {
+  return new Promise((resolve5, reject) => {
+    execFile(
+      "git",
+      ["status", "--porcelain=v1", "-uall"],
+      { cwd: rootPath, timeout: 1e4 },
+      (error, stdout) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve5(stdout);
+      }
+    );
+  });
+}
+function useGitStatus(rootPath, enabled = true) {
+  const minRefreshMs = Math.max(100, DEFAULT_CONFIG.debounceDelay * 2);
+  const [statusMap, setStatusMap] = useState3(/* @__PURE__ */ new Map());
+  const [isGitRepo, setIsGitRepo] = useState3(false);
+  const [isLoading, setIsLoading] = useState3(false);
+  const [error, setError] = useState3(null);
+  const mountedRef = useRef2(true);
+  const inFlightRef = useRef2(false);
+  const pendingRefreshRef = useRef2(false);
+  const refreshTimerRef = useRef2(null);
+  const lastFetchAtRef = useRef2(0);
+  const fetchGitStatus = useCallback3(async () => {
+    if (inFlightRef.current) {
+      pendingRefreshRef.current = true;
+      return;
+    }
+    inFlightRef.current = true;
+    lastFetchAtRef.current = Date.now();
+    if (!enabled || !rootPath) {
+      setStatusMap((prev) => prev.size === 0 ? prev : /* @__PURE__ */ new Map());
+      setIsGitRepo(false);
+      setError(null);
+      inFlightRef.current = false;
+      pendingRefreshRef.current = false;
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const repoCheck = await isGitRepo(rootPath);
+      if (!mountedRef.current) return;
+      if (!repoCheck) {
+        setIsGitRepo(false);
+        setStatusMap((prev) => prev.size === 0 ? prev : /* @__PURE__ */ new Map());
+        setIsLoading(false);
+        return;
+      }
+      setIsGitRepo(true);
+      const output = await getGitStatus(rootPath);
+      if (!mountedRef.current) return;
+      const map = parsePorcelain(output);
+      setStatusMap((prev) => areStatusMapsEqual(prev, map) ? prev : map);
+    } catch (err) {
+      if (!mountedRef.current) return;
+      setError(err);
+      setIsGitRepo(false);
+      setStatusMap((prev) => prev.size === 0 ? prev : /* @__PURE__ */ new Map());
+    } finally {
+      if (mountedRef.current) {
+        setIsLoading(false);
+      }
+      inFlightRef.current = false;
+      if (pendingRefreshRef.current && mountedRef.current && enabled && rootPath) {
+        pendingRefreshRef.current = false;
+        const elapsedMs = Date.now() - lastFetchAtRef.current;
+        const delayMs = Math.max(0, minRefreshMs - elapsedMs);
+        if (refreshTimerRef.current) {
+          clearTimeout(refreshTimerRef.current);
+        }
+        refreshTimerRef.current = setTimeout(() => {
+          refreshTimerRef.current = null;
+          fetchGitStatus();
+        }, delayMs);
+      }
+    }
+  }, [rootPath, enabled, minRefreshMs]);
+  const refresh = useCallback3(() => {
+    if (!enabled || !rootPath) {
+      return;
+    }
+    if (inFlightRef.current) {
+      pendingRefreshRef.current = true;
+      return;
+    }
+    const elapsedMs = Date.now() - lastFetchAtRef.current;
+    if (elapsedMs < minRefreshMs) {
+      pendingRefreshRef.current = true;
+      if (refreshTimerRef.current) {
+        return;
+      }
+      const delayMs = minRefreshMs - elapsedMs;
+      refreshTimerRef.current = setTimeout(() => {
+        refreshTimerRef.current = null;
+        pendingRefreshRef.current = false;
+        fetchGitStatus();
+      }, delayMs);
+      return;
+    }
+    pendingRefreshRef.current = false;
+    if (refreshTimerRef.current) {
+      clearTimeout(refreshTimerRef.current);
+      refreshTimerRef.current = null;
+    }
+    fetchGitStatus();
+  }, [enabled, rootPath, minRefreshMs, fetchGitStatus]);
+  useEffect2(() => {
+    mountedRef.current = true;
+    fetchGitStatus();
+    return () => {
+      mountedRef.current = false;
+      inFlightRef.current = false;
+      pendingRefreshRef.current = false;
+      if (refreshTimerRef.current) {
+        clearTimeout(refreshTimerRef.current);
+        refreshTimerRef.current = null;
+      }
+    };
+  }, [fetchGitStatus]);
+  return {
+    statusMap,
+    isGitRepo,
+    refresh,
+    isLoading,
+    error
+  };
+}
+
+// src/hooks/useWatcher.js
+import { useEffect as useEffect3, useState as useState4, useRef as useRef3 } from "react";
+import chokidar from "chokidar";
+function shouldUsePolling(rootPath) {
+  const envOverride = process.env.FTREE_USE_POLLING;
+  if (envOverride === "1" || envOverride === "true") {
+    return true;
+  }
+  if (envOverride === "0" || envOverride === "false") {
+    return false;
+  }
+  const isWsl = process.platform === "linux" && (process.env.WSL_INTEROP || process.env.WSL_DISTRO_NAME);
+  if (isWsl && typeof rootPath === "string" && rootPath.startsWith("/mnt/")) {
+    return true;
+  }
+  return false;
+}
+function useWatcher(rootPath, onTreeChange, options = {}) {
+  const debounceMs = options.debounceMs ?? DEFAULT_CONFIG.debounceDelay;
+  const [isWatching, setIsWatching] = useState4(false);
+  const watcherRef = useRef3(null);
+  const onTreeChangeRef = useRef3(onTreeChange);
+  const mountedRef = useRef3(true);
+  const debounceTimerRef = useRef3(null);
+  const pendingChangesRef = useRef3(/* @__PURE__ */ new Map());
+  const sawAnyEventRef = useRef3(false);
+  useEffect3(() => {
+    onTreeChangeRef.current = onTreeChange;
+  }, [onTreeChange]);
+  useEffect3(() => {
+    mountedRef.current = true;
+    if (options.noWatch || !rootPath) {
+      setIsWatching(false);
+      return () => {
+        mountedRef.current = false;
+      };
+    }
+    const usePolling = shouldUsePolling(rootPath);
+    const watcher = chokidar.watch(rootPath, {
+      ignored: /(^|[\/\\])\.\./,
+      persistent: true,
+      ignoreInitial: true,
+      followSymlinks: false,
+      ...usePolling ? { usePolling: true, interval: 300 } : {}
+    });
+    watcherRef.current = watcher;
+    const flushPendingChange = () => {
+      debounceTimerRef.current = null;
+      const hadAnyEvent = sawAnyEventRef.current;
+      const pendingMap = pendingChangesRef.current;
+      sawAnyEventRef.current = false;
+      pendingChangesRef.current = /* @__PURE__ */ new Map();
+      if (hadAnyEvent && mountedRef.current && onTreeChangeRef.current) {
+        const batch = Array.from(pendingMap.entries()).map(([path, event]) => ({ event, path }));
+        onTreeChangeRef.current(batch);
+      }
+    };
+    watcher.on("all", (event, path) => {
+      sawAnyEventRef.current = true;
+      if (event === "add" || event === "addDir") {
+        pendingChangesRef.current.set(path, event);
+      } else if (event === "change") {
+        if (!pendingChangesRef.current.has(path)) {
+          pendingChangesRef.current.set(path, event);
+        }
+      }
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+      }
+      debounceTimerRef.current = setTimeout(flushPendingChange, debounceMs);
+    });
+    watcher.on("error", () => {
+      setIsWatching(false);
+    });
+    watcher.on("ready", () => {
+      setIsWatching(true);
+    });
+    return () => {
+      mountedRef.current = false;
+      if (debounceTimerRef.current) {
+        clearTimeout(debounceTimerRef.current);
+        debounceTimerRef.current = null;
+      }
+      pendingChangesRef.current = /* @__PURE__ */ new Map();
+      sawAnyEventRef.current = false;
+      if (watcherRef.current) {
+        watcherRef.current.close();
+        watcherRef.current = null;
+      }
+      setIsWatching(false);
+    };
+  }, [rootPath, options.noWatch, debounceMs]);
+  return { isWatching };
+}
+
+// src/hooks/useChangedFiles.js
+import { useState as useState5, useCallback as useCallback4, useEffect as useEffect4, useRef as useRef4 } from "react";
+var MODIFY_HIGHLIGHT_DURATION = 6e4;
+var ADD_HIGHLIGHT_DURATION = 12e4;
+function useChangedFiles() {
+  const [changedFiles, setChangedFiles] = useState5(/* @__PURE__ */ new Map());
+  const timeoutMapRef = useRef4(/* @__PURE__ */ new Map());
+  const markChanged = useCallback4((filePath, status = "M") => {
+    const normalizedStatus = normalizeChangeStatus(status);
+    if (!filePath || !normalizedStatus) {
+      return;
+    }
+    let mergedStatus = normalizedStatus;
+    setChangedFiles((prev) => {
+      const next = new Map(prev);
+      const existingStatus = next.get(filePath) || "";
+      mergedStatus = mergeChangeStatus(existingStatus, normalizedStatus);
+      next.set(filePath, mergedStatus);
+      return next;
+    });
+    const existingTimer = timeoutMapRef.current.get(filePath);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const durationMs = mergedStatus === "A" ? ADD_HIGHLIGHT_DURATION : MODIFY_HIGHLIGHT_DURATION;
+    const timer = setTimeout(() => {
+      setChangedFiles((prev) => {
+        if (!prev.has(filePath)) {
+          return prev;
+        }
+        const next = new Map(prev);
+        next.delete(filePath);
+        return next;
+      });
+      timeoutMapRef.current.delete(filePath);
+    }, durationMs);
+    timeoutMapRef.current.set(filePath, timer);
+  }, []);
+  useEffect4(() => {
+    return () => {
+      for (const timer of timeoutMapRef.current.values()) {
+        clearTimeout(timer);
+      }
+      timeoutMapRef.current.clear();
+    };
+  }, []);
+  return {
+    changedFiles,
+    markChanged,
+    getStatus: (filePath) => normalizeChangeStatus(changedFiles.get(filePath) || "")
+  };
+}
+
+// src/App.jsx
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function setupCleanExit() {
+  const onExit = () => {
+    process.stdout.write("\n");
+  };
+  process.on("exit", onExit);
+  process.on("SIGINT", () => {
+    onExit();
+    process.exit(0);
+  });
+  return () => {
+    process.off("exit", onExit);
+    process.off("SIGINT");
+  };
+}
+function App({ rootPath, options = {}, version: version2 }) {
+  const rootAbsPath = resolve3(rootPath);
+  const iconSet = resolveIconSet({ cliIconSet: options.iconSet, noIcons: options.noIcons });
+  const theme = getTheme(resolveThemeName({ cliTheme: options.theme }));
+  const [selectedPath, setSelectedPath] = useState6(null);
+  useEffect5(() => setupCleanExit(), []);
+  const { tree, flatList, refreshFlatList, rebuildTree } = useTree(rootPath, options);
+  const { statusMap, isGitRepo, refresh: refreshGit } = useGitStatus(
+    rootPath,
+    !options.noGit
+  );
+  const { cursor, viewportStart, setCursor } = useNavigation(
+    flatList,
+    rebuildTree,
+    refreshFlatList
+  );
+  const cursorRef = useRef5(cursor);
+  cursorRef.current = cursor;
+  const { changedFiles, markChanged } = useChangedFiles();
+  useMemo(() => {
+    if (!tree) {
+      return;
+    }
+    const gitStatuses = isGitRepo ? statusMap : /* @__PURE__ */ new Map();
+    applyGitStatus(tree, gitStatuses);
+    applyChangeIndicators(tree, gitStatuses, changedFiles);
+  }, [statusMap, tree, isGitRepo, changedFiles]);
+  const [termSize, setTermSize] = useState6({
+    width: process.stdout.columns,
+    height: process.stdout.rows
+  });
+  useEffect5(() => {
+    const handleResize = () => {
+      setTermSize({
+        width: process.stdout.columns,
+        height: process.stdout.rows
+      });
+    };
+    process.stdout.on("resize", handleResize);
+    return () => {
+      process.stdout.off("resize", handleResize);
+    };
+  }, []);
+  useEffect5(() => {
+    if (flatList.length > 0 && cursor >= 0 && cursor < flatList.length) {
+      const currentNode = flatList[cursor];
+      if (currentNode) {
+        setSelectedPath((prev) => prev === currentNode.path ? prev : currentNode.path);
+      }
+    }
+  }, [cursor, flatList]);
+  useEffect5(() => {
+    if (!selectedPath || flatList.length === 0) {
+      return;
+    }
+    const newIndex = flatList.findIndex((node) => node.path === selectedPath);
+    if (newIndex === -1) {
+      setCursor((prev) => Math.min(prev, flatList.length - 1));
+      return;
+    }
+    if (newIndex !== cursorRef.current) {
+      setCursor(newIndex);
+    }
+  }, [flatList, selectedPath, setCursor]);
+  const toTreeRelativePath = useCallback5((watchPath) => {
+    if (!watchPath) {
+      return "";
+    }
+    const absolutePath = isAbsolute(watchPath) ? watchPath : resolve3(rootAbsPath, watchPath);
+    const relativePath = relative3(rootAbsPath, absolutePath);
+    if (!relativePath || relativePath.startsWith("..")) {
+      return "";
+    }
+    return relativePath.split(sep3).join("/");
+  }, [rootAbsPath]);
+  const handleTreeChange = useCallback5((eventsOrEvent, watchPath) => {
+    const batch = Array.isArray(eventsOrEvent) ? eventsOrEvent : [{ event: eventsOrEvent, path: watchPath }];
+    for (const item of batch) {
+      if (!item) continue;
+      const changeStatus = mapWatcherEventToChangeStatus(item.event);
+      const relativePath = toTreeRelativePath(item.path);
+      if (changeStatus && relativePath) {
+        markChanged(relativePath, changeStatus);
+      }
+    }
+    rebuildTree(true);
+    if (isGitRepo) {
+      refreshGit();
+    }
+  }, [rebuildTree, isGitRepo, refreshGit, markChanged, toTreeRelativePath]);
+  const { isWatching } = useWatcher(rootPath, handleTreeChange, {
+    noWatch: options.noWatch
+  });
+  const helpEnabled = options.help !== false;
+  const statusBarHeight = helpEnabled ? 2 : 1;
+  const viewportHeight = termSize.height - statusBarHeight;
+  const termWidth = termSize.width;
+  const { fileCount, dirCount } = calculateCounts(flatList);
+  const { summary: gitSummary } = calculateGitStatus(statusMap);
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", height: "100%", children: [
+    /* @__PURE__ */ jsx4(Box4, { flexGrow: 1, children: /* @__PURE__ */ jsx4(
+      TreeView_default,
+      {
+        flatList,
+        cursor,
+        viewportStart,
+        viewportHeight,
+        termWidth,
+        iconSet,
+        theme
+      }
+    ) }),
+    /* @__PURE__ */ jsx4(
+      StatusBar_default,
+      {
+        version: version2,
+        rootPath,
+        fileCount,
+        dirCount,
+        isWatching,
+        gitEnabled: !options.noGit,
+        isGitRepo,
+        gitSummary,
+        showHelp: helpEnabled,
+        termWidth,
+        iconSet,
+        theme
+      }
+    )
+  ] });
+}
+
+// src/cli.js
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var pkgPath = resolve4(__dirname, "../package.json");
+var { version } = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+function printHelp() {
+  console.log(`
+ftree - Terminal file explorer with git awareness and live updates
+
+USAGE:
+  ftree [path]
+
+ARGUMENTS:
+  [path]        Path to directory to explore (default: current directory)
+
+OPTIONS:
+  -h, --help    Print this help message
+  -v, --version Print version information
+      --no-git  Disable git integration
+      --no-icons Use ASCII icons (disable emoji/nerd icons)
+      --no-watch Disable file watching
+      --icon-set <emoji|nerd|ascii>  Icon set (default: emoji). You can also set FTREE_ICON_SET.
+      --theme <vscode>  UI theme (default: vscode). You can also set FTREE_THEME.
+
+EXAMPLES:
+  ftree                    # Explore current directory
+  ftree ~/projects         # Explore specific directory
+  ftree /path/to/project   # Explore project path
+
+EXIT CODES:
+  0 - Success
+  1 - Invalid path or error
+`);
+}
+function printVersion() {
+  console.log(`ftree v${version}`);
+}
+function validatePath(path) {
+  const resolvedPath = resolve4(path);
+  if (!existsSync2(resolvedPath)) {
+    return {
+      valid: false,
+      error: `Error: Path does not exist: ${resolvedPath}`
+    };
+  }
+  try {
+    const stats = statSync3(resolvedPath);
+    if (!stats.isDirectory()) {
+      return {
+        valid: false,
+        error: `Error: Path is not a directory: ${resolvedPath}`
+      };
+    }
+  } catch (err) {
+    return {
+      valid: false,
+      error: `Error: Cannot access path: ${resolvedPath} (${err.message})`
+    };
+  }
+  try {
+    readdirSync3(resolvedPath);
+  } catch (err) {
+    return {
+      valid: false,
+      error: `Error: Cannot read directory: ${resolvedPath} (${err.message})`
+    };
+  }
+  return { valid: true };
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = {
+    help: false,
+    version: false,
+    options: {
+      noIcons: false,
+      noGit: false,
+      noWatch: false,
+      help: true,
+      // show help line by default
+      iconSet: void 0,
+      theme: void 0
+    }
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      result.help = true;
+      continue;
+    }
+    if (arg === "-v" || arg === "--version") {
+      result.version = true;
+      continue;
+    }
+    if (arg === "--no-git") {
+      result.options.noGit = true;
+      continue;
+    }
+    if (arg === "--no-icons") {
+      result.options.noIcons = true;
+      continue;
+    }
+    if (arg === "--no-watch") {
+      result.options.noWatch = true;
+      continue;
+    }
+    if (arg === "--no-help") {
+      result.options.help = false;
+      continue;
+    }
+    if (arg === "--icon-set" || arg.startsWith("--icon-set=")) {
+      const value = arg.includes("=") ? arg.split("=")[1] : args[++i];
+      if (!value) {
+        console.error("Error: --icon-set requires a value (emoji|nerd|ascii)");
+        process.exit(1);
+      }
+      result.options.iconSet = value;
+      continue;
+    }
+    if (arg === "--theme" || arg.startsWith("--theme=")) {
+      const value = arg.includes("=") ? arg.split("=")[1] : args[++i];
+      if (!value) {
+        console.error("Error: --theme requires a value");
+        process.exit(1);
+      }
+      result.options.theme = value;
+      continue;
+    }
+    if (!arg.startsWith("-")) {
+      result.path = arg;
+      continue;
+    }
+    console.error(`Error: Unknown option: ${arg}`);
+    console.error("Use --help for usage information");
+    process.exit(1);
+  }
+  return result;
+}
+function main() {
+  const { path, help, version: version2, options } = parseArgs();
+  if (help) {
+    printHelp();
+    process.exit(0);
+  }
+  if (version2) {
+    printVersion();
+    process.exit(0);
+  }
+  const targetPath = path || ".";
+  const validation = validatePath(targetPath);
+  if (!validation.valid) {
+    console.error(validation.error);
+    process.exit(1);
+  }
+  const resolvedPath = resolve4(targetPath);
+  render(React5.createElement(App, { rootPath: resolvedPath, options, version: `v${version2}` }));
+}
+main();