ftreeview 0.1.1

package/src/hooks/useGitStatus.js

@@ -0,0 +1,347 @@
+/**
+ * useGitStatus - Git Status Hook
+ *
+ * Provides git status information for files in a directory tree.
+ * Parses git status --porcelain=v1 -uall output to get file status.
+ *
+ * This hook detects non-git directories and handles errors gracefully.
+ */
+
+import { execFile } from 'node:child_process';
+import { useEffect, useState, useCallback, useRef } from 'react';
+import { DEFAULT_CONFIG } from '../lib/constants.js';
+
+/**
+ * Parse git status --porcelain=v1 -uall output into a status map
+ *
+ * Porcelain format: XY filename
+ * X = staged status, Y = unstaged status
+ *
+ * Status codes:
+ * - "M " (modified, staged) → "M" green
+ * - " M" (modified, unstaged) → "M" yellow
+ * - "MM" (modified both) → "M" yellow
+ * - "A " (added, staged) → "A" green
+ * - "?? " (untracked) → "U" green
+ * - "D " (deleted, staged) → "D" red
+ * - " D" (deleted, unstaged) → "D" red
+ * - "R " (renamed, staged) → "R" cyan
+ * - "!!" (ignored) → skip
+ *
+ * @param {string} output - Raw git status --porcelain=v1 -uall output
+ * @returns {Map<string, string>} Map of relative paths to status codes
+ */
+export function parsePorcelain(output) {
+  const statusMap = new Map();
+
+  // Split output into lines and process each
+  const lines = output.split('\n').filter(Boolean);
+
+  for (const line of lines) {
+    // Skip ignored files
+    if (line.startsWith('!!')) {
+      continue;
+    }
+
+    // Extract status codes (first two characters)
+    const stagedStatus = line[0];
+    const unstagedStatus = line[1];
+
+    // Extract filename (after status codes and space)
+    // Handle quoted filenames with spaces (format: XY "filename")
+    let filePath;
+    if (line[2] === '"') {
+      // Quoted filename - find closing quote
+      const endQuote = line.indexOf('"', 3);
+      filePath = line.slice(3, endQuote);
+    } else {
+      // Simple filename - split by space
+      filePath = line.slice(3);
+    }
+
+    // Determine status based on porcelain codes
+    let statusCode = '';
+
+    // Check for rename (R in staged position, possibly followed by original filename)
+    // Format: R  oldname -> newname
+    if (stagedStatus === 'R') {
+      statusCode = 'R'; // Renamed (cyan)
+      // Handle "R  old -> new" format - extract the new filename
+      if (filePath.includes(' -> ')) {
+        filePath = filePath.split(' -> ')[1];
+      }
+    }
+    // Deleted (staged or unstaged)
+    else if (stagedStatus === 'D' || unstagedStatus === 'D') {
+      statusCode = 'D'; // Deleted (red)
+    }
+    // Added (staged)
+    else if (stagedStatus === 'A') {
+      statusCode = 'A'; // Added (green)
+    }
+    // Modified - check both staged and unstaged
+    else if (stagedStatus === 'M' || unstagedStatus === 'M') {
+      statusCode = 'M'; // Modified (yellow if unstaged, green if staged)
+    }
+    // Untracked
+    else if (stagedStatus === '?' && unstagedStatus === '?') {
+      statusCode = 'U'; // Untracked (green)
+    }
+    // Conflicted (both stage deleted, or merged but unresolved)
+    else if (
+      (stagedStatus === 'D' && unstagedStatus === 'D') ||
+      (stagedStatus === 'A' && unstagedStatus === 'A') ||
+      (stagedStatus === 'U' || unstagedStatus === 'U')
+    ) {
+      statusCode = 'C'; // Conflicted
+    }
+
+    // Only add if we have a status code
+    if (statusCode) {
+      // Git reports untracked directories with a trailing slash (e.g. "?? newdir/").
+      // Strip it so it matches our FileNode.path (which never includes a trailing slash).
+      if (filePath.endsWith('/') || filePath.endsWith('\\')) {
+        filePath = filePath.slice(0, -1);
+      }
+
+      // Normalize path separators to forward slashes (git uses forward slashes)
+      const normalizedPath = filePath.replace(/\\/g, '/');
+      statusMap.set(normalizedPath, statusCode);
+    }
+  }
+
+  return statusMap;
+}
+
+/**
+ * Compare two status maps for structural equality.
+ *
+ * @param {Map<string, string>} first - First status map
+ * @param {Map<string, string>} second - Second status map
+ * @returns {boolean} True when maps contain identical keys and values
+ */
+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;
+}
+
+/**
+ * Checks if the given path is within a git repository
+ *
+ * @param {string} rootPath - Path to check
+ * @returns {Promise<boolean>} True if path is in a git repository
+ */
+function isGitRepo(rootPath) {
+  return new Promise((resolve) => {
+    execFile(
+      'git',
+      ['rev-parse', '--git-dir'],
+      { cwd: rootPath, timeout: 5000 },
+      (error) => {
+        // If git command succeeds (no error), we're in a git repo
+        resolve(!error);
+      }
+    );
+  });
+}
+
+/**
+ * Executes git status --porcelain=v1 -uall and returns the output
+ *
+ * @param {string} rootPath - Root path of the repository
+ * @returns {Promise<string>} Git status output
+ */
+function getGitStatus(rootPath) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      'git',
+      ['status', '--porcelain=v1', '-uall'],
+      { cwd: rootPath, timeout: 10000 },
+      (error, stdout) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(stdout);
+      }
+    );
+  });
+}
+
+/**
+ * React hook for git status integration
+ *
+ * This hook runs git status on mount and provides:
+ * - statusMap: Map of relative paths to status codes
+ * - isGitRepo: Boolean indicating if in a git repository
+ * - refresh: Function to manually refresh git status
+ * - isLoading: Boolean indicating if git status is being fetched
+ * - error: Error object if git status failed
+ *
+ * @param {string} rootPath - Root directory path
+ * @param {boolean} enabled - Whether git status is enabled
+ * @returns {{statusMap: Map<string, string>, isGitRepo: boolean, refresh: function, isLoading: boolean, error: Error|null}}
+ */
+export function useGitStatus(rootPath, enabled = true) {
+  const minRefreshMs = Math.max(100, DEFAULT_CONFIG.debounceDelay * 2);
+  const [statusMap, setStatusMap] = useState(new Map());
+  const [isGitRepo, setIsGitRepo] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const mountedRef = useRef(true);
+  const inFlightRef = useRef(false);
+  const pendingRefreshRef = useRef(false);
+  const refreshTimerRef = useRef(null);
+  const lastFetchAtRef = useRef(0);
+
+  /**
+   * Fetches and parses git status
+   */
+  const fetchGitStatus = useCallback(async () => {
+    if (inFlightRef.current) {
+      pendingRefreshRef.current = true;
+      return;
+    }
+
+    inFlightRef.current = true;
+    lastFetchAtRef.current = Date.now();
+
+    if (!enabled || !rootPath) {
+      setStatusMap((prev) => (prev.size === 0 ? prev : new Map()));
+      setIsGitRepo(false);
+      setError(null);
+      inFlightRef.current = false;
+      pendingRefreshRef.current = false;
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      // First check if we're in a git repository
+      const repoCheck = await isGitRepo(rootPath);
+
+      if (!mountedRef.current) return;
+
+      if (!repoCheck) {
+        // Not a git repository
+        setIsGitRepo(false);
+        setStatusMap((prev) => (prev.size === 0 ? prev : new Map()));
+        setIsLoading(false);
+        return;
+      }
+
+      setIsGitRepo(true);
+
+      // Fetch git status
+      const output = await getGitStatus(rootPath);
+
+      if (!mountedRef.current) return;
+
+      // Parse output into status map
+      const map = parsePorcelain(output);
+      setStatusMap((prev) => (areStatusMapsEqual(prev, map) ? prev : map));
+    } catch (err) {
+      if (!mountedRef.current) return;
+
+      // Handle errors gracefully
+      // Common errors: git not installed, not a git repo, permission denied
+      setError(err);
+      setIsGitRepo(false);
+      setStatusMap((prev) => (prev.size === 0 ? prev : 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]);
+
+  /**
+   * Manual refresh function with coalescing/throttling.
+   */
+  const refresh = useCallback(() => {
+    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]);
+
+  // Fetch on mount and when dependencies change
+  useEffect(() => {
+    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,
+  };
+}

package/src/hooks/useIgnore.js

@@ -0,0 +1,182 @@
+/**
+ * useIgnore - Gitignore Filtering Hook
+ *
+ * Provides gitignore-style filtering functionality using the 'ignore' package.
+ * Supports loading .gitignore files from the root and nested directories.
+ */
+
+import { existsSync, readdirSync, statSync, readFileSync } from 'node:fs';
+import { resolve, join, relative, sep } from 'node:path';
+import ignore from 'ignore';
+
+/**
+ * Default patterns that are always applied (unless --no-ignore is set)
+ */
+const DEFAULT_PATTERNS = [
+  '.git',
+  '.git/',
+  '.git/**',
+  'node_modules',
+  'node_modules/',
+];
+
+/**
+ * Finds all .gitignore files in a directory tree
+ *
+ * @param {string} rootPath - Root directory path
+ * @returns {Map<string, string>} Map of directory paths to their .gitignore content
+ */
+function findGitignoreFiles(rootPath) {
+  const gitignoreMap = new Map();
+
+  /**
+   * Recursively scan for .gitignore files
+   * @param {string} dirPath - Current directory to scan
+   */
+  function scanDirectory(dirPath) {
+    try {
+      const entries = readdirSync(dirPath, { withFileTypes: true });
+
+      // Check if this directory has a .gitignore file
+      const gitignorePath = join(dirPath, '.gitignore');
+      if (existsSync(gitignorePath)) {
+        // We'll read these lazily when needed to avoid excessive I/O
+        gitignoreMap.set(dirPath, gitignorePath);
+      }
+
+      // Recurse into subdirectories
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== '.git') {
+          const subPath = join(dirPath, entry.name);
+          scanDirectory(subPath);
+        }
+      }
+    } catch (error) {
+      // Skip directories we can't read (permission errors, etc.)
+    }
+  }
+
+  scanDirectory(rootPath);
+  return gitignoreMap;
+}
+
+/**
+ * Creates an ignore filter function based on .gitignore files
+ *
+ * @param {string} rootPath - Root directory path
+ * @param {object} options - Configuration options
+ * @param {boolean} [options.showIgnored=false] - If true, don't filter anything (--no-ignore)
+ * @param {string[]} [options.extraIgnorePatterns] - Additional patterns to ignore
+ * @returns {object} Object with shouldIgnore method and addPattern method
+ */
+export function createIgnoreFilter(rootPath, options = {}) {
+  const { showIgnored = false, extraIgnorePatterns = [] } = options;
+
+  // If showIgnored is true, return a pass-through filter
+  if (showIgnored) {
+    return {
+      shouldIgnore: (relativePath) => false,
+      addPattern: () => {},
+      filter: (paths) => paths,
+    };
+  }
+
+  // Initialize the ignore instance
+  const ig = ignore();
+
+  // Add default patterns (unless showIgnored is true)
+  for (const pattern of DEFAULT_PATTERNS) {
+    ig.add(pattern);
+  }
+
+  // Add extra patterns from options
+  if (extraIgnorePatterns.length > 0) {
+    ig.add(extraIgnorePatterns);
+  }
+
+  // Find all .gitignore files
+  const gitignoreMap = findGitignoreFiles(rootPath);
+
+  // Track which .gitignore files we've already loaded
+  const loadedIgnores = new Set();
+
+  /**
+   * Ensures .gitignore patterns for a given path are loaded
+   * This implements lazy loading - we only load patterns when we encounter a directory
+   *
+   * @param {string} dirAbsPath - Absolute path to directory
+   */
+  function loadPatternsForDirectory(dirAbsPath) {
+    if (loadedIgnores.has(dirAbsPath)) {
+      return; // Already loaded
+    }
+
+    const gitignorePath = gitignoreMap.get(dirAbsPath);
+    if (gitignorePath && existsSync(gitignorePath)) {
+      try {
+        // Read and parse the .gitignore file
+        const content = readFileSync(gitignorePath, 'utf-8');
+        ig.add(content);
+        loadedIgnores.add(dirAbsPath);
+      } catch (error) {
+        // Silently ignore read errors
+      }
+    }
+  }
+
+  /**
+   * Checks if a relative path should be ignored
+   *
+   * @param {string} relativePath - Path relative to root (forward slashes)
+   * @returns {boolean} True if the path should be ignored
+   */
+  function shouldIgnore(relativePath) {
+    // Empty string (root directory) is never ignored
+    if (relativePath === '') {
+      return false;
+    }
+
+    // Normalize path to use forward slashes
+    const normalizedPath = relativePath.split(sep).join('/');
+
+    return ig.ignores(normalizedPath);
+  }
+
+  /**
+   * Filters an array of paths, keeping only non-ignored ones
+   *
+   * @param {string[]} paths - Array of relative paths
+   * @returns {string[]} Filtered array of paths
+   */
+  function filter(paths) {
+    return ig.filter(paths);
+  }
+
+  /**
+   * Adds a pattern to the ignore filter
+   *
+   * @param {string|string[]} pattern - Pattern or array of patterns to add
+   */
+  function addPattern(pattern) {
+    ig.add(pattern);
+  }
+
+  return {
+    shouldIgnore,
+    filter,
+    addPattern,
+    loadPatternsForDirectory,
+  };
+}
+
+/**
+ * React hook for creating an ignore filter
+ * This is a convenience wrapper around createIgnoreFilter
+ *
+ * @param {string} rootPath - Root directory path
+ * @param {object} options - Configuration options
+ * @returns {object} Filter object with shouldIgnore method
+ */
+export function useIgnore(rootPath, options = {}) {
+  return createIgnoreFilter(rootPath, options);
+}