@tmustier/pi-files-widget 0.1.7 → 0.1.9

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this extension will be documented in this file.
 
+## [0.1.9] - 2026-01-26
+
+### Changed
+- Bind render requests to avoid undefined context with the latest pi-tui
+
+## [0.1.8] - 2026-01-26
+
+### Changed
+- Compute line counts asynchronously with loading indicators
+- Build git repo trees from git file lists to avoid filesystem scans
+- Add progressive filesystem scanning with safe mode for large folders
+- Reduce refresh work to git metadata updates
+
 ## [0.1.7] - 2026-01-26
 
 ### Changed

package/README.md

@@ -117,4 +117,6 @@ If missing, `/review` or `/diff` will show a clear install prompt.
 
 - Untracked files show as `[UNTRACKED]` and open in normal view.
 - Folder LOCs are shown only when the folder is collapsed (expanded folders would duplicate counts).
+- Line counts load asynchronously; the header shows activity while counts are computed.
+- Large non-git folders load progressively and may show `[partial]` while loading in safe mode.
 - Git status refreshes every 3 seconds while `/files` is open.

package/browser.ts

@@ -1,16 +1,25 @@
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { Key, matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
-import { basename } from "node:path";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join, relative, resolve, sep } from "node:path";
 
 import {
   DEFAULT_BROWSER_HEIGHT,
+  LINE_COUNT_BATCH_DELAY_MS,
+  LINE_COUNT_BATCH_SIZE,
   MAX_BROWSER_HEIGHT,
+  MAX_LINE_COUNT_BYTES,
+  MAX_TREE_DEPTH,
   MIN_PANEL_HEIGHT,
   POLL_INTERVAL_MS,
+  SCAN_BATCH_DELAY_MS,
+  SCAN_BATCH_SIZE,
+  SAFE_MODE_ENTRY_THRESHOLD,
 } from "./constants";
-import { getGitBranch, getGitDiffStats, getGitStatus } from "./git";
-import { buildFileTree, flattenTree, getIgnoredNames } from "./file-tree";
-import type { FileNode, FlatNode } from "./types";
+import { getGitBranch, getGitDiffStats, getGitFileList, getGitStatus, isGitRepo } from "./git";
+import { buildFileTreeFromPaths, flattenTree, getIgnoredNames, sortChildren, updateTreeStats } from "./file-tree";
+import type { DiffStats, FileNode, FlatNode } from "./types";
 import { isIgnoredStatus, isUntrackedStatus } from "./utils";
 import { createViewer, type CommentPayload, type ViewerAction } from "./viewer";
 import { isPrintableChar } from "./input-utils";
@@ -27,11 +36,23 @@ interface BrowserStats {
   deletions: number;
 }
 
+type ScanMode = "full" | "safe" | "none";
+
+interface ScanState {
+  mode: ScanMode;
+  isScanning: boolean;
+  isPartial: boolean;
+  pending: number;
+  spinnerIndex: number;
+}
+
 interface BrowserState {
   root: FileNode | null;
   flatList: FlatNode[];
   fullList: FlatNode[];
   stats: BrowserStats;
+  nodeByPath: Map<string, FileNode>;
+  scanState: ScanState;
   selectedIndex: number;
   searchQuery: string;
   searchMode: boolean;
@@ -45,50 +66,49 @@ interface ChangedFile {
   ancestors: FileNode[];
 }
 
-function captureExpandedPaths(root: FileNode | null): Set<string> {
-  const expandedPaths = new Set<string>();
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
-  function traverse(node: FileNode): void {
-    if (node.isDirectory && node.expanded) {
-      expandedPaths.add(node.path);
-    }
-    if (node.children) {
-      for (const child of node.children) {
-        traverse(child);
-      }
-    }
+function findNodeByPath(root: FileNode | null, path: string): FileNode | null {
+  if (!root) return null;
+  if (root.path === path) return root;
+  if (!root.children) return null;
+
+  for (const child of root.children) {
+    const found = findNodeByPath(child, path);
+    if (found) return found;
   }
 
-  if (root) traverse(root);
-  return expandedPaths;
+  return null;
 }
 
-function restoreExpandedPaths(root: FileNode | null, expandedPaths: Set<string>): void {
-  function traverse(node: FileNode): void {
-    if (node.isDirectory) {
-      node.expanded = expandedPaths.has(node.path);
-    }
+function indexNodes(root: FileNode | null, map: Map<string, FileNode>): void {
+  map.clear();
+  if (!root) return;
+  const stack: FileNode[] = [root];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (!node) continue;
+    map.set(node.path, node);
     if (node.children) {
       for (const child of node.children) {
-        traverse(child);
+        stack.push(child);
       }
     }
   }
-
-  if (root) traverse(root);
 }
 
-function findNodeByPath(root: FileNode | null, path: string): FileNode | null {
-  if (!root) return null;
-  if (root.path === path) return root;
-  if (!root.children) return null;
-
-  for (const child of root.children) {
-    const found = findNodeByPath(child, path);
-    if (found) return found;
-  }
+function getNodeDepth(node: FileNode, cwd: string): number {
+  if (node.path === cwd) return 0;
+  const rel = relative(cwd, node.path);
+  if (!rel) return 0;
+  return rel.split(sep).length;
+}
 
-  return null;
+function shouldSafeMode(cwd: string): boolean {
+  const resolved = resolve(cwd);
+  const home = resolve(homedir());
+  const root = resolve(sep);
+  return resolved === home || resolved === root;
 }
 
 function collectChangedFiles(node: FileNode, ancestors: FileNode[] = []): ChangedFile[] {
@@ -166,7 +186,8 @@ function formatNodeMeta(node: FileNode, theme: Theme): string {
 function formatNodeName(node: FileNode, theme: Theme): string {
   if (isIgnoredStatus(node.gitStatus)) return theme.fg("dim", node.name);
   if (node.isDirectory) {
-    return node.hasChangedChildren ? theme.fg("warning", node.name) : theme.fg("accent", node.name);
+    const label = node.hasChangedChildren ? theme.fg("warning", node.name) : theme.fg("accent", node.name);
+    return node.loading ? `${label}${theme.fg("dim", " ⏳")}` : label;
   }
   if (node.gitStatus) return theme.fg("warning", node.name);
   return node.name;
@@ -188,22 +209,44 @@ export function createFileBrowser(
   agentModifiedFiles: Set<string>,
   theme: Theme,
   onClose: () => void,
-  requestComment: (payload: CommentPayload, comment: string) => void
+  requestComment: (payload: CommentPayload, comment: string) => void,
+  requestRender: () => void
 ): BrowserController {
-  let gitStatus = getGitStatus(cwd);
-  let diffStats = getGitDiffStats(cwd);
-  const gitBranch = getGitBranch(cwd);
   const ignored = getIgnoredNames();
+  const repo = isGitRepo(cwd);
+  let gitStatus = repo ? getGitStatus(cwd) : new Map<string, string>();
+  let diffStats = repo ? getGitDiffStats(cwd) : new Map<string, DiffStats>();
+  const gitBranch = repo ? getGitBranch(cwd) : "";
 
   const viewer = createViewer(cwd, theme, requestComment);
 
-  const root = buildFileTree(cwd, cwd, gitStatus, diffStats, ignored, agentModifiedFiles);
+  const root = repo
+    ? buildFileTreeFromPaths(cwd, getGitFileList(cwd), gitStatus, diffStats, ignored, agentModifiedFiles)
+    : {
+      name: ".",
+      path: cwd,
+      isDirectory: true,
+      children: undefined,
+      expanded: true,
+      hasChangedChildren: false,
+    };
+
+  const safeMode = !repo && shouldSafeMode(cwd);
+  const scanState: ScanState = {
+    mode: repo ? "none" : safeMode ? "safe" : "full",
+    isScanning: false,
+    isPartial: safeMode,
+    pending: 0,
+    spinnerIndex: 0,
+  };
 
   const browser: BrowserState = {
     root,
     flatList: [],
     fullList: [],
     stats: getTreeStats(root),
+    nodeByPath: new Map<string, FileNode>(),
+    scanState,
     selectedIndex: 0,
     searchQuery: "",
     searchMode: false,
@@ -212,26 +255,332 @@ export function createFileBrowser(
     lastPollTime: Date.now(),
   };
 
+  indexNodes(browser.root, browser.nodeByPath);
   browser.flatList = browser.root ? flattenTree(browser.root) : [];
   browser.fullList = browser.root ? flattenTree(browser.root, 0, true, true) : [];
 
-  function refreshGitStatus(): void {
+  const lineCountCache = new Map<string, { size: number; mtimeMs: number; count: number }>();
+  const lineCountQueue: FileNode[] = [];
+  const lineCountPending = new Set<string>();
+  let lineCountTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const scanQueue: Array<{ node: FileNode; depth: number }> = [];
+  const scanQueued = new Set<string>();
+  let scanTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const normalizeGitPath = (path: string): string => path.split(sep).join("/");
+
+  function refreshLists(): void {
+    browser.flatList = browser.root ? flattenTree(browser.root) : [];
+    browser.fullList = browser.root ? flattenTree(browser.root, 0, true, true) : [];
+  }
+
+  function queueLineCount(node: FileNode, force = false): void {
+    if (node.isDirectory) return;
+    if (!force && node.lineCount !== undefined) return;
+    if (lineCountPending.has(node.path)) return;
+    lineCountPending.add(node.path);
+    lineCountQueue.push(node);
+    if (!lineCountTimer) {
+      lineCountTimer = setTimeout(processLineCountBatch, LINE_COUNT_BATCH_DELAY_MS);
+    }
+  }
+
+  function queueLineCountsForTree(rootNode: FileNode | null): void {
+    if (!rootNode) return;
+    const stack: FileNode[] = [rootNode];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (!node) continue;
+      if (node.isDirectory) {
+        if (node.children) {
+          for (const child of node.children) {
+            stack.push(child);
+          }
+        }
+      } else {
+        queueLineCount(node);
+      }
+    }
+  }
+
+  async function updateLineCount(node: FileNode): Promise<void> {
+    try {
+      const fileStat = await stat(node.path);
+      if (fileStat.size > MAX_LINE_COUNT_BYTES) {
+        node.lineCount = undefined;
+        return;
+      }
+      const cached = lineCountCache.get(node.path);
+      if (cached && cached.size === fileStat.size && cached.mtimeMs === fileStat.mtimeMs) {
+        node.lineCount = cached.count;
+        return;
+      }
+      const content = await readFile(node.path, "utf-8");
+      const count = content.split("\n").length;
+      node.lineCount = count;
+      lineCountCache.set(node.path, { size: fileStat.size, mtimeMs: fileStat.mtimeMs, count });
+    } catch {
+      node.lineCount = undefined;
+    }
+  }
+
+  async function processLineCountBatch(): Promise<void> {
+    lineCountTimer = null;
+    if (!browser.root) return;
+    const batch = lineCountQueue.splice(0, LINE_COUNT_BATCH_SIZE);
+    if (batch.length === 0) return;
+
+    await Promise.all(
+      batch.map(async node => {
+        await updateLineCount(node);
+        lineCountPending.delete(node.path);
+      })
+    );
+
+    updateTreeStats(browser.root);
+    browser.stats = getTreeStats(browser.root);
+    refreshLists();
+    requestRender();
+
+    if (lineCountQueue.length > 0) {
+      lineCountTimer = setTimeout(processLineCountBatch, LINE_COUNT_BATCH_DELAY_MS);
+    }
+  }
+
+  function shouldAutoScan(depth: number): boolean {
+    if (browser.scanState.mode === "safe") {
+      return depth <= 0;
+    }
+    return depth <= MAX_TREE_DEPTH;
+  }
+
+  function getScanBatchSize(): number {
+    return browser.scanState.mode === "safe" ? 1 : SCAN_BATCH_SIZE;
+  }
+
+  function getScanDelay(): number {
+    return browser.scanState.mode === "safe" ? SCAN_BATCH_DELAY_MS * 4 : SCAN_BATCH_DELAY_MS;
+  }
+
+  function enqueueScan(node: FileNode, depth: number, force = false): void {
+    if (depth > MAX_TREE_DEPTH) return;
+    if (!force && browser.scanState.mode === "safe" && depth > 0) return;
+    if (node.children !== undefined || node.loading) return;
+    if (scanQueued.has(node.path)) return;
+
+    node.loading = true;
+    scanQueued.add(node.path);
+    scanQueue.push({ node, depth });
+    browser.scanState.pending = scanQueue.length;
+    browser.scanState.isScanning = true;
+
+    if (!scanTimer) {
+      scanTimer = setTimeout(processScanBatch, getScanDelay());
+    }
+  }
+
+  async function scanDirectory(node: FileNode, depth: number): Promise<void> {
+    try {
+      const entries = await readdir(node.path, { withFileTypes: true });
+      const sorted = [...entries].sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+
+      if (node.path === cwd && browser.scanState.mode === "full" && sorted.length >= SAFE_MODE_ENTRY_THRESHOLD) {
+        browser.scanState.mode = "safe";
+        browser.scanState.isPartial = true;
+        scanQueue.length = 0;
+        scanQueued.clear();
+      }
+
+      const dirs: FileNode[] = [];
+      const files: FileNode[] = [];
+
+      for (const entry of sorted) {
+        if (ignored.has(entry.name) || entry.name.startsWith(".")) continue;
+        const fullPath = join(node.path, entry.name);
+        if (entry.isDirectory()) {
+          const dirNode: FileNode = {
+            name: entry.name,
+            path: fullPath,
+            isDirectory: true,
+            children: undefined,
+            expanded: depth + 1 < 1,
+            hasChangedChildren: false,
+          };
+          dirs.push(dirNode);
+          browser.nodeByPath.set(fullPath, dirNode);
+          if (shouldAutoScan(depth + 1)) {
+            enqueueScan(dirNode, depth + 1);
+          }
+        } else {
+          const fileNode: FileNode = {
+            name: entry.name,
+            path: fullPath,
+            isDirectory: false,
+            agentModified: agentModifiedFiles.has(fullPath),
+          };
+          files.push(fileNode);
+          browser.nodeByPath.set(fullPath, fileNode);
+          queueLineCount(fileNode);
+        }
+      }
+
+      node.children = [...dirs, ...files];
+    } catch {
+      node.children = [];
+    } finally {
+      node.loading = false;
+      scanQueued.delete(node.path);
+    }
+  }
+
+  async function processScanBatch(): Promise<void> {
+    scanTimer = null;
+    if (!browser.root) return;
+    const batch = scanQueue.splice(0, getScanBatchSize());
+    if (batch.length === 0) {
+      browser.scanState.isScanning = false;
+      browser.scanState.pending = 0;
+      return;
+    }
+
+    for (const item of batch) {
+      await scanDirectory(item.node, item.depth);
+    }
+
+    browser.scanState.pending = scanQueue.length;
+    browser.scanState.isScanning = scanQueue.length > 0;
+
+    updateTreeStats(browser.root);
+    browser.stats = getTreeStats(browser.root);
+    refreshLists();
+    requestRender();
+
+    if (scanQueue.length > 0) {
+      scanTimer = setTimeout(processScanBatch, getScanDelay());
+    }
+  }
+
+  function stopBackgroundTasks(): void {
+    if (lineCountTimer) {
+      clearTimeout(lineCountTimer);
+      lineCountTimer = null;
+    }
+    if (scanTimer) {
+      clearTimeout(scanTimer);
+      scanTimer = null;
+    }
+  }
+
+  function applyAgentModified(): void {
+    for (const node of browser.nodeByPath.values()) {
+      if (!node.isDirectory) {
+        node.agentModified = agentModifiedFiles.has(node.path);
+      }
+    }
+  }
+
+  function applyGitUpdates(): void {
+    for (const node of browser.nodeByPath.values()) {
+      if (node.isDirectory) continue;
+      const relPath = normalizeGitPath(relative(cwd, node.path));
+      node.gitStatus = gitStatus.get(relPath);
+      node.diffStats = diffStats.get(relPath);
+    }
+  }
+
+  function ensureFileNode(relPath: string): FileNode | null {
+    if (!browser.root) return null;
+    let normalized = relPath.trim();
+    if (!normalized) return null;
+    if (normalized.startsWith("./")) {
+      normalized = normalized.slice(2);
+    }
+    normalized = normalizeGitPath(normalized);
+    const parts = normalized.split("/").filter(Boolean);
+    if (parts.length === 0) return null;
+    if (parts.length - 1 > MAX_TREE_DEPTH) return null;
+
+    let current = browser.root;
+    let currentRel = "";
+
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (ignored.has(part) || part.startsWith(".")) return null;
+      currentRel = currentRel ? `${currentRel}/${part}` : part;
+      const dirPath = join(cwd, currentRel);
+      let dirNode = browser.nodeByPath.get(dirPath);
+      if (!dirNode) {
+        const depth = i + 1;
+        dirNode = {
+          name: part,
+          path: dirPath,
+          isDirectory: true,
+          children: [],
+          expanded: depth < 1,
+          hasChangedChildren: false,
+        };
+        current.children ??= [];
+        current.children.push(dirNode);
+        sortChildren(current);
+        browser.nodeByPath.set(dirPath, dirNode);
+      }
+      current = dirNode;
+    }
+
+    const fileName = parts[parts.length - 1];
+    if (ignored.has(fileName) || fileName.startsWith(".")) return null;
+
+    const filePath = join(cwd, normalized);
+    const existing = browser.nodeByPath.get(filePath);
+    if (existing) return existing;
+
+    const fileNode: FileNode = {
+      name: fileName,
+      path: filePath,
+      isDirectory: false,
+      gitStatus: gitStatus.get(normalized),
+      agentModified: agentModifiedFiles.has(filePath),
+      diffStats: diffStats.get(normalized),
+    };
+
+    current.children ??= [];
+    current.children.push(fileNode);
+    sortChildren(current);
+    browser.nodeByPath.set(filePath, fileNode);
+    return fileNode;
+  }
+
+  function addUntrackedNodes(): void {
+    for (const [relPath, status] of gitStatus.entries()) {
+      if (!isUntrackedStatus(status)) continue;
+      const node = ensureFileNode(relPath);
+      if (node) {
+        node.gitStatus = status;
+        node.diffStats = diffStats.get(relPath);
+        queueLineCount(node, true);
+      }
+    }
+  }
+
+  function refreshMetadata(): void {
+    if (!browser.root) return;
     const previousDisplayList = getDisplayList();
     const currentPath = previousDisplayList[browser.selectedIndex]?.node.path;
     const viewingFile = viewer.getFile();
     const viewingFilePath = viewingFile?.path;
 
-    const expandedPaths = captureExpandedPaths(browser.root);
+    if (repo) {
+      gitStatus = getGitStatus(cwd);
+      diffStats = getGitDiffStats(cwd);
+      applyGitUpdates();
+      addUntrackedNodes();
+    }
 
-    gitStatus = getGitStatus(cwd);
-    diffStats = getGitDiffStats(cwd);
-    browser.root = buildFileTree(cwd, cwd, gitStatus, diffStats, ignored, agentModifiedFiles);
+    applyAgentModified();
+    updateTreeStats(browser.root);
     browser.stats = getTreeStats(browser.root);
-
-    restoreExpandedPaths(browser.root, expandedPaths);
-
-    browser.flatList = browser.root ? flattenTree(browser.root) : [];
-    browser.fullList = browser.root ? flattenTree(browser.root, 0, true, true) : [];
+    refreshLists();
 
     const updatedDisplayList = getDisplayList();
     if (currentPath) {
@@ -244,7 +593,7 @@ export function createFileBrowser(
     browser.selectedIndex = Math.min(browser.selectedIndex, Math.max(0, updatedDisplayList.length - 1));
 
     if (viewingFilePath && browser.root) {
-      const newNode = findNodeByPath(browser.root, viewingFilePath);
+      const newNode = browser.nodeByPath.get(viewingFilePath) ?? findNodeByPath(browser.root, viewingFilePath);
       if (newNode) {
         if (newNode.lineCount === undefined && viewingFile?.lineCount !== undefined) {
           newNode.lineCount = viewingFile.lineCount;
@@ -254,6 +603,12 @@ export function createFileBrowser(
     }
   }
 
+  if (repo) {
+    queueLineCountsForTree(browser.root);
+  } else if (browser.root) {
+    enqueueScan(browser.root, 0, true);
+  }
+
   function getDisplayList(): FlatNode[] {
     let list = browser.searchQuery ? browser.fullList : browser.flatList;
 
@@ -317,7 +672,10 @@ export function createFileBrowser(
   function toggleDir(node: FileNode): void {
     if (node.isDirectory) {
       node.expanded = !node.expanded;
-      browser.flatList = browser.root ? flattenTree(browser.root) : [];
+      if (!repo && node.expanded && node.children === undefined) {
+        enqueueScan(node, getNodeDepth(node, cwd), true);
+      }
+      refreshLists();
     }
   }
 
@@ -338,16 +696,32 @@ export function createFileBrowser(
     if (stats.additions > 0) statsDisplay += theme.fg("success", ` +${stats.additions}`);
     if (stats.deletions > 0) statsDisplay += theme.fg("error", ` -${stats.deletions}`);
 
+    const hasActivity = browser.scanState.isScanning || lineCountPending.size > 0;
+    if (hasActivity) {
+      browser.scanState.spinnerIndex = (browser.scanState.spinnerIndex + 1) % SPINNER_FRAMES.length;
+    }
+    const spinner = SPINNER_FRAMES[browser.scanState.spinnerIndex];
+    const activityParts: string[] = [];
+    if (browser.scanState.isScanning) activityParts.push(`${spinner} scanning`);
+    if (lineCountPending.size > 0) activityParts.push(`${spinner} counts`);
+    const activityIndicator = activityParts.length > 0 ? theme.fg("dim", ` ${activityParts.join(" ")}`) : "";
+    const partialIndicator = browser.scanState.isPartial ? theme.fg("warning", " [partial]") : "";
+
     const searchIndicator = browser.searchMode
       ? theme.fg("accent", `  /${browser.searchQuery}█`)
       : "";
 
-    lines.push(truncateToWidth(theme.bold(pathDisplay) + branchDisplay + statsDisplay + searchIndicator, width));
+    lines.push(
+      truncateToWidth(theme.bold(pathDisplay) + branchDisplay + statsDisplay + activityIndicator + partialIndicator + searchIndicator, width)
+    );
     lines.push(theme.fg("borderMuted", "─".repeat(width)));
 
     const displayList = getDisplayList();
     if (displayList.length === 0) {
-      lines.push(theme.fg("dim", "  (no files" + (browser.searchQuery ? " matching '" + browser.searchQuery + "'" : "") + ")"));
+      const emptyLabel = browser.scanState.isScanning
+        ? "  (loading...)"
+        : "  (no files" + (browser.searchQuery ? " matching '" + browser.searchQuery + "'" : "") + ")";
+      lines.push(theme.fg("dim", emptyLabel));
       for (let i = 1; i < browser.browserHeight; i++) {
         lines.push("");
       }
@@ -422,6 +796,7 @@ export function createFileBrowser(
     const displayList = getDisplayList();
 
     if (matchesKey(data, "q") && !browser.searchMode) {
+      stopBackgroundTasks();
       onClose();
       return;
     }
@@ -430,6 +805,7 @@ export function createFileBrowser(
         browser.searchMode = false;
         browser.searchQuery = "";
       } else {
+        stopBackgroundTasks();
         onClose();
       }
       return;
@@ -521,9 +897,9 @@ export function createFileBrowser(
   return {
     render(width: number): string[] {
       const now = Date.now();
-      if (now - browser.lastPollTime > POLL_INTERVAL_MS) {
+      if (repo && now - browser.lastPollTime > POLL_INTERVAL_MS) {
         browser.lastPollTime = now;
-        refreshGitStatus();
+        refreshMetadata();
       }
 
       if (viewer.isOpen()) {

package/constants.ts

@@ -1,6 +1,11 @@
 export const MAX_TREE_DEPTH = 6;
 export const POLL_INTERVAL_MS = 3000;
 export const MAX_LINE_COUNT_BYTES = 256 * 1024;
+export const LINE_COUNT_BATCH_SIZE = 8;
+export const LINE_COUNT_BATCH_DELAY_MS = 30;
+export const SCAN_BATCH_SIZE = 4;
+export const SCAN_BATCH_DELAY_MS = 25;
+export const SAFE_MODE_ENTRY_THRESHOLD = 200;
 
 export const DEFAULT_VIEWER_HEIGHT = 18;
 export const DEFAULT_BROWSER_HEIGHT = 15;

package/file-tree.ts

@@ -1,29 +1,177 @@
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { basename, join, relative } from "node:path";
+import { join } from "node:path";
 
-import { MAX_LINE_COUNT_BYTES, MAX_TREE_DEPTH } from "./constants";
+import { MAX_TREE_DEPTH } from "./constants";
 import type { DiffStats, FileNode, FlatNode } from "./types";
 
-const lineCountCache = new Map<string, { mtimeMs: number; size: number; count: number }>();
+const collator = new Intl.Collator(undefined, { sensitivity: "base" });
 
-export function getFileLineCount(filePath: string, size: number, mtimeMs: number): number | undefined {
-  const cached = lineCountCache.get(filePath);
-  if (cached && cached.size === size && cached.mtimeMs === mtimeMs) {
-    return cached.count;
+function compareNodes(a: FileNode, b: FileNode): number {
+  if (a.isDirectory !== b.isDirectory) {
+    return a.isDirectory ? -1 : 1;
   }
+  return collator.compare(a.name, b.name);
+}
+
+function shouldIgnoreSegment(segment: string, ignored: Set<string>): boolean {
+  return ignored.has(segment) || segment.startsWith(".");
+}
+
+export function sortChildren(node: FileNode): void {
+  if (!node.children || node.children.length === 0) return;
+  node.children.sort(compareNodes);
+}
+
+function sortTree(node: FileNode): void {
+  sortChildren(node);
+  if (node.children) {
+    for (const child of node.children) {
+      if (child.isDirectory) {
+        sortTree(child);
+      }
+    }
+  }
+}
+
+export function updateTreeStats(root: FileNode | null): void {
+  if (!root) return;
+
+  function traverse(node: FileNode): {
+    totalLines: number;
+    totalAdditions: number;
+    totalDeletions: number;
+    lineCountComplete: boolean;
+    hasChanges: boolean;
+  } {
+    if (!node.isDirectory) {
+      const totalLines = node.lineCount ?? 0;
+      const totalAdditions = node.diffStats?.additions ?? 0;
+      const totalDeletions = node.diffStats?.deletions ?? 0;
+      const lineCountComplete = node.lineCount !== undefined;
+      const hasChanges = Boolean(node.gitStatus || node.agentModified);
+      return { totalLines, totalAdditions, totalDeletions, lineCountComplete, hasChanges };
+    }
+
+    let totalLines = 0;
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+    let lineCountComplete = true;
+    let hasChanges = false;
+
+    if (node.children) {
+      for (const child of node.children) {
+        const stats = traverse(child);
+        totalLines += stats.totalLines;
+        totalAdditions += stats.totalAdditions;
+        totalDeletions += stats.totalDeletions;
+        if (!stats.lineCountComplete) {
+          lineCountComplete = false;
+        }
+        if (stats.hasChanges) {
+          hasChanges = true;
+        }
+      }
+    }
 
-  if (size > MAX_LINE_COUNT_BYTES) {
-    return undefined;
+    node.totalLines = totalLines;
+    node.totalAdditions = totalAdditions;
+    node.totalDeletions = totalDeletions;
+    node.lineCountComplete = lineCountComplete;
+    node.hasChangedChildren = hasChanges;
+
+    return { totalLines, totalAdditions, totalDeletions, lineCountComplete, hasChanges };
   }
 
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    const count = content.split("\n").length;
-    lineCountCache.set(filePath, { mtimeMs, size, count });
-    return count;
-  } catch {
-    return undefined;
+  traverse(root);
+}
+
+export function buildFileTreeFromPaths(
+  cwd: string,
+  filePaths: string[],
+  gitStatus: Map<string, string>,
+  diffStats: Map<string, DiffStats>,
+  ignored: Set<string>,
+  agentModified: Set<string>
+): FileNode {
+  const root: FileNode = {
+    name: ".",
+    path: cwd,
+    isDirectory: true,
+    children: [],
+    expanded: true,
+    hasChangedChildren: false,
+  };
+
+  const directoryMap = new Map<string, FileNode>();
+  directoryMap.set("", root);
+  const seenFiles = new Set<string>();
+
+  for (const rawPath of filePaths) {
+    let normalized = rawPath.trim();
+    if (!normalized) continue;
+    if (normalized.startsWith("./")) {
+      normalized = normalized.slice(2);
+    }
+    normalized = normalized.replace(/\\/g, "/");
+
+    const parts = normalized.split("/").filter(Boolean);
+    if (parts.length === 0) continue;
+    const dirDepth = parts.length - 1;
+    if (dirDepth > MAX_TREE_DEPTH) continue;
+
+    let current = root;
+    let relPath = "";
+    let skip = false;
+
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (shouldIgnoreSegment(part, ignored)) {
+        skip = true;
+        break;
+      }
+      relPath = relPath ? `${relPath}/${part}` : part;
+      let dirNode = directoryMap.get(relPath);
+      if (!dirNode) {
+        const depth = i + 1;
+        dirNode = {
+          name: part,
+          path: join(cwd, relPath),
+          isDirectory: true,
+          children: [],
+          expanded: depth < 1,
+          hasChangedChildren: false,
+        };
+        directoryMap.set(relPath, dirNode);
+        current.children?.push(dirNode);
+      }
+      current = dirNode;
+    }
+
+    if (skip) continue;
+
+    const fileName = parts[parts.length - 1];
+    if (shouldIgnoreSegment(fileName, ignored)) continue;
+
+    const fileRelPath = parts.join("/");
+    if (seenFiles.has(fileRelPath)) continue;
+    seenFiles.add(fileRelPath);
+
+    const filePath = join(cwd, fileRelPath);
+    const fileGitStatus = gitStatus.get(fileRelPath);
+    const fileDiffStats = diffStats.get(fileRelPath);
+
+    current.children?.push({
+      name: fileName,
+      path: filePath,
+      isDirectory: false,
+      gitStatus: fileGitStatus,
+      agentModified: agentModified.has(filePath),
+      diffStats: fileDiffStats,
+    });
   }
+
+  sortTree(root);
+  updateTreeStats(root);
+  return root;
 }
 
 export function getIgnoredNames(): Set<string> {
@@ -48,113 +196,6 @@ export function getIgnoredNames(): Set<string> {
   ]);
 }
 
-export function buildFileTree(
-  dir: string,
-  cwd: string,
-  gitStatus: Map<string, string>,
-  diffStats: Map<string, DiffStats>,
-  ignored: Set<string>,
-  agentModified: Set<string>,
-  depth = 0
-): FileNode | null {
-  if (depth > MAX_TREE_DEPTH) return null;
-
-  const name = basename(dir) || dir;
-  if (ignored.has(name)) return null;
-
-  const node: FileNode = {
-    name: depth === 0 ? "." : name,
-    path: dir,
-    isDirectory: true,
-    children: [],
-    expanded: depth < 1,
-    hasChangedChildren: false,
-  };
-
-  try {
-    const entries = readdirSync(dir);
-    const dirs: FileNode[] = [];
-    const files: FileNode[] = [];
-
-    for (const entry of entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))) {
-      if (ignored.has(entry) || entry.startsWith(".")) continue;
-
-      const fullPath = join(dir, entry);
-      let stat;
-      try {
-        stat = statSync(fullPath);
-      } catch {
-        continue;
-      }
-
-      if (stat.isDirectory()) {
-        const child = buildFileTree(fullPath, cwd, gitStatus, diffStats, ignored, agentModified, depth + 1);
-        if (child) {
-          dirs.push(child);
-          // Propagate hasChangedChildren up
-          if (child.hasChangedChildren || child.gitStatus) {
-            node.hasChangedChildren = true;
-          }
-        }
-      } else {
-        const relPath = relative(cwd, fullPath);
-        const fileGitStatus = gitStatus.get(relPath);
-        const fileDiffStats = diffStats.get(relPath);
-
-        if (fileGitStatus) {
-          node.hasChangedChildren = true;
-        }
-
-        files.push({
-          name: entry,
-          path: fullPath,
-          isDirectory: false,
-          gitStatus: fileGitStatus,
-          agentModified: agentModified.has(fullPath),
-          lineCount: getFileLineCount(fullPath, stat.size, stat.mtimeMs),
-          diffStats: fileDiffStats,
-        });
-      }
-    }
-
-    node.children = [...dirs, ...files];
-
-    // Calculate aggregated stats for this directory
-    let totalLines = 0;
-    let totalAdditions = 0;
-    let totalDeletions = 0;
-    let lineCountComplete = true;
-
-    for (const child of node.children) {
-      if (child.isDirectory) {
-        totalLines += child.totalLines ?? 0;
-        totalAdditions += child.totalAdditions ?? 0;
-        totalDeletions += child.totalDeletions ?? 0;
-        if (child.lineCountComplete === false) {
-          lineCountComplete = false;
-        }
-      } else {
-        if (child.lineCount === undefined) {
-          lineCountComplete = false;
-        } else {
-          totalLines += child.lineCount;
-        }
-        if (child.diffStats) {
-          totalAdditions += child.diffStats.additions;
-          totalDeletions += child.diffStats.deletions;
-        }
-      }
-    }
-
-    node.totalLines = totalLines;
-    node.totalAdditions = totalAdditions;
-    node.totalDeletions = totalDeletions;
-    node.lineCountComplete = lineCountComplete;
-  } catch {}
-
-  return node;
-}
-
 export function flattenTree(
   node: FileNode,
   depth = 0,

package/git.ts

@@ -11,11 +11,14 @@ export function isGitRepo(cwd: string): boolean {
   }
 }
 
-export function getGitStatus(cwd: string): Map<string, string> {
+export function getGitStatus(cwd: string, options: { includeIgnored?: boolean } = {}): Map<string, string> {
   const status = new Map<string, string>();
   try {
-    // Include ignored files with --ignored flag
-    const output = execSync("git status --porcelain --ignored", { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe" });
+    const flags = ["--porcelain"];
+    if (options.includeIgnored !== false) {
+      flags.push("--ignored");
+    }
+    const output = execSync(`git status ${flags.join(" ")}`, { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe" });
     for (const line of output.split("\n")) {
       if (line.length < 3) continue;
       const statusCode = line.slice(0, 2).trim() || "?";
@@ -26,6 +29,38 @@ export function getGitStatus(cwd: string): Map<string, string> {
   return status;
 }
 
+export function getGitFileList(cwd: string): string[] {
+  const files = new Set<string>();
+  try {
+    const tracked = execSync("git ls-files -z", { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe" });
+    for (const entry of tracked.split("\0")) {
+      if (entry) files.add(entry);
+    }
+  } catch {}
+
+  try {
+    const statusOutput = execSync("git status --porcelain -uall -z", { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe" });
+    const entries = statusOutput.split("\0");
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry) continue;
+      const statusCode = entry.slice(0, 2).trim();
+      let filePath = entry.slice(3);
+      if ((statusCode.startsWith("R") || statusCode.startsWith("C")) && entries[i + 1]) {
+        i += 1;
+        filePath = entries[i];
+      } else if (filePath.includes(" -> ")) {
+        filePath = filePath.split(" -> ").pop() || filePath;
+      }
+      if (filePath) {
+        files.add(filePath);
+      }
+    }
+  } catch {}
+
+  return Array.from(files);
+}
+
 export function getGitBranch(cwd: string): string {
   try {
     return execSync("git branch --show-current", { cwd, encoding: "utf-8", timeout: 2000, stdio: "pipe" }).trim();

package/index.ts

@@ -39,17 +39,18 @@ export default function editorExtension(pi: ExtensionAPI): void {
           } as any);
         };
 
-        const browser = createFileBrowser(cwd, agentModifiedFiles, theme, cleanup, requestComment);
+        const requestRender = () => tui.requestRender();
+        const browser = createFileBrowser(cwd, agentModifiedFiles, theme, cleanup, requestComment, requestRender);
 
         pollInterval = setInterval(() => {
-          tui.requestRender();
+          requestRender();
         }, POLL_INTERVAL_MS);
 
         return {
           render: (w) => browser.render(w),
           handleInput: (data) => {
             browser.handleInput(data);
-            tui.requestRender();
+            requestRender();
           },
           invalidate: () => browser.invalidate(),
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmustier/pi-files-widget",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "In-terminal file browser and viewer for Pi.",
   "license": "MIT",
   "author": "Thomas Mustier",

package/types.ts

@@ -19,6 +19,7 @@ export interface FileNode {
   totalAdditions?: number;
   totalDeletions?: number;
   lineCountComplete?: boolean;
+  loading?: boolean;
 }
 
 export interface FlatNode {