tmux-ide 2.1.5 → 2.6.0

package/src/widgets/explorer/tree-model.test.ts

@@ -1,214 +0,0 @@
-import { describe, it, beforeEach, afterEach, expect } from "bun:test";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import ignore from "ignore";
-import {
-  buildRootNodes,
-  expandNode,
-  collapseNode,
-  flattenVisibleNodes,
-  refreshExpandedNodes,
-} from "./tree-model.ts";
-
-let tmpDir: string;
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-tree-test-"));
-  mkdirSync(join(tmpDir, "src"));
-  mkdirSync(join(tmpDir, "src", "lib"));
-  writeFileSync(join(tmpDir, "src", "index.ts"), "");
-  writeFileSync(join(tmpDir, "src", "lib", "utils.ts"), "");
-  mkdirSync(join(tmpDir, "docs"));
-  writeFileSync(join(tmpDir, "package.json"), "{}");
-  writeFileSync(join(tmpDir, "README.md"), "");
-});
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-describe("buildRootNodes", () => {
-  it("returns dirs first, then files, alphabetically", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    const names = nodes.map((n) => n.entry.name);
-    expect(names).toEqual(["docs", "src", "package.json", "README.md"]);
-  });
-
-  it("sets depth to 0 for all root nodes", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    expect(nodes.every((n) => n.depth === 0)).toBeTruthy();
-  });
-
-  it("attaches git status from map", () => {
-    const ig = ignore();
-    const gitMap = new Map([["package.json", "M"]]);
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, gitMap, false);
-    const pkg = nodes.find((n) => n.entry.name === "package.json");
-    expect(pkg?.gitStatus).toBe("M");
-  });
-
-  it("sets gitStatus to null when not in map", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    expect(nodes.every((n) => n.gitStatus === null)).toBeTruthy();
-  });
-
-  it("filters hidden files when showHidden is false", () => {
-    writeFileSync(join(tmpDir, ".hidden"), "");
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    expect(!nodes.some((n) => n.entry.name === ".hidden")).toBeTruthy();
-  });
-
-  it("includes hidden files when showHidden is true", () => {
-    writeFileSync(join(tmpDir, ".hidden"), "");
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), true);
-    expect(nodes.some((n) => n.entry.name === ".hidden")).toBeTruthy();
-  });
-
-  it("uses projectRoot for relative paths when scanning a subdirectory", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(join(tmpDir, "src"), tmpDir, ig, new Map(), false);
-    const indexNode = nodes.find((n) => n.entry.name === "index.ts");
-    expect(indexNode).toBeTruthy();
-    expect(indexNode.entry.path).toBe("src/index.ts");
-  });
-});
-
-describe("expandNode", () => {
-  it("populates children with correct depth", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    const src = nodes.find((n) => n.entry.name === "src")!;
-    expandNode(src, tmpDir, ig, new Map(), false);
-    expect(src.expanded).toBe(true);
-    expect(src.children.length > 0).toBeTruthy();
-    expect(src.children.every((c) => c.depth === 1)).toBeTruthy();
-  });
-
-  it("does not expand files", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    const pkg = nodes.find((n) => n.entry.name === "package.json")!;
-    expandNode(pkg, tmpDir, ig, new Map(), false);
-    expect(pkg.expanded).toBe(false);
-    expect(pkg.children.length).toBe(0);
-  });
-
-  it("does not re-expand already expanded node", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    const src = nodes.find((n) => n.entry.name === "src")!;
-    expandNode(src, tmpDir, ig, new Map(), false);
-    const originalChildren = src.children;
-    expandNode(src, tmpDir, ig, new Map(), false);
-    expect(src.children).toBe(originalChildren);
-  });
-
-  it("shows nested children with incremented depth", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    const src = nodes.find((n) => n.entry.name === "src")!;
-    expandNode(src, tmpDir, ig, new Map(), false);
-    const lib = src.children.find((c) => c.entry.name === "lib")!;
-    expandNode(lib, tmpDir, ig, new Map(), false);
-    expect(lib.children.every((c) => c.depth === 2)).toBeTruthy();
-  });
-});
-
-describe("collapseNode", () => {
-  it("clears children and sets expanded to false", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    const src = nodes.find((n) => n.entry.name === "src")!;
-    expandNode(src, tmpDir, ig, new Map(), false);
-    expect(src.children.length > 0).toBeTruthy();
-    collapseNode(src);
-    expect(src.expanded).toBe(false);
-    expect(src.children.length).toBe(0);
-  });
-});
-
-describe("flattenVisibleNodes", () => {
-  it("returns only root nodes when nothing is expanded", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    const flat = flattenVisibleNodes(nodes);
-    expect(flat.length).toBe(nodes.length);
-  });
-
-  it("includes children of expanded nodes", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    const src = nodes.find((n) => n.entry.name === "src")!;
-    expandNode(src, tmpDir, ig, new Map(), false);
-    const flat = flattenVisibleNodes(nodes);
-    expect(flat.length > nodes.length).toBeTruthy();
-    const srcIdx = flat.indexOf(src);
-    expect(srcIdx >= 0).toBeTruthy();
-    expect(flat[srcIdx + 1]?.depth).toBe(1);
-  });
-
-  it("returns correct depth-first order with nested expansion", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    const src = nodes.find((n) => n.entry.name === "src")!;
-    expandNode(src, tmpDir, ig, new Map(), false);
-    const lib = src.children.find((c) => c.entry.name === "lib")!;
-    expandNode(lib, tmpDir, ig, new Map(), false);
-    const flat = flattenVisibleNodes(nodes);
-    const names = flat.map((n) => n.entry.name);
-    const srcIdx = names.indexOf("src");
-    const libIdx = names.indexOf("lib");
-    const utilsIdx = names.indexOf("utils.ts");
-    expect(srcIdx < libIdx).toBeTruthy();
-    expect(libIdx < utilsIdx).toBeTruthy();
-  });
-});
-
-describe("refreshExpandedNodes", () => {
-  it("picks up new files in expanded directories", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    const src = nodes.find((n) => n.entry.name === "src")!;
-    expandNode(src, tmpDir, ig, new Map(), false);
-    const countBefore = src.children.length;
-
-    writeFileSync(join(tmpDir, "src", "new-file.ts"), "");
-
-    const refreshed = refreshExpandedNodes(nodes, tmpDir, ig, new Map(), false);
-    const refreshedSrc = refreshed.find((n) => n.entry.name === "src")!;
-    expect(refreshedSrc.expanded).toBeTruthy();
-    expect(refreshedSrc.children.length > countBefore).toBeTruthy();
-    expect(refreshedSrc.children.some((c) => c.entry.name === "new-file.ts")).toBeTruthy();
-  });
-
-  it("preserves expanded state of nested directories", () => {
-    const ig = ignore();
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-    const src = nodes.find((n) => n.entry.name === "src")!;
-    expandNode(src, tmpDir, ig, new Map(), false);
-    const lib = src.children.find((c) => c.entry.name === "lib")!;
-    expandNode(lib, tmpDir, ig, new Map(), false);
-
-    const refreshed = refreshExpandedNodes(nodes, tmpDir, ig, new Map(), false);
-    const refreshedSrc = refreshed.find((n) => n.entry.name === "src")!;
-    const refreshedLib = refreshedSrc.children.find((c) => c.entry.name === "lib")!;
-    expect(refreshedLib.expanded).toBe(true);
-    expect(refreshedLib.children.length > 0).toBeTruthy();
-  });
-
-  it("updates git status on refresh", () => {
-    const ig = ignore();
-    const gitMap = new Map([["package.json", "M"]]);
-    const nodes = buildRootNodes(tmpDir, tmpDir, ig, new Map(), false);
-
-    const refreshed = refreshExpandedNodes(nodes, tmpDir, ig, gitMap, false);
-    const pkg = refreshed.find((n) => n.entry.name === "package.json");
-    expect(pkg?.gitStatus).toBe("M");
-  });
-});

package/src/widgets/explorer/tree-model.ts

@@ -1,103 +0,0 @@
-import { readDirectory, type FileEntry, type Ignore } from "../lib/files.ts";
-
-export interface TreeNode {
-  entry: FileEntry;
-  expanded: boolean;
-  children: TreeNode[];
-  depth: number;
-  gitStatus: string | null;
-}
-
-export function buildRootNodes(
-  scanDir: string,
-  projectRoot: string,
-  ig: Ignore,
-  gitMap: Map<string, string>,
-  showHidden: boolean,
-  showIgnored: boolean = false,
-): TreeNode[] {
-  return readDirectory(scanDir, projectRoot, ig, showHidden, showIgnored).map((entry) => ({
-    entry,
-    expanded: false,
-    children: [],
-    depth: 0,
-    gitStatus: gitMap.get(entry.path) ?? null,
-  }));
-}
-
-export function expandNode(
-  node: TreeNode,
-  projectRoot: string,
-  ig: Ignore,
-  gitMap: Map<string, string>,
-  showHidden: boolean,
-): void {
-  if (!node.entry.isDir || node.expanded) return;
-  node.expanded = true;
-  node.children = readDirectory(node.entry.absolutePath, projectRoot, ig, showHidden).map(
-    (entry) => ({
-      entry,
-      expanded: false,
-      children: [],
-      depth: node.depth + 1,
-      gitStatus: gitMap.get(entry.path) ?? null,
-    }),
-  );
-}
-
-export function collapseNode(node: TreeNode): void {
-  node.expanded = false;
-  node.children = [];
-}
-
-export function flattenVisibleNodes(nodes: TreeNode[]): TreeNode[] {
-  const result: TreeNode[] = [];
-  function walk(list: TreeNode[]) {
-    for (const node of list) {
-      result.push(node);
-      if (node.expanded) walk(node.children);
-    }
-  }
-  walk(nodes);
-  return result;
-}
-
-export function refreshExpandedNodes(
-  nodes: TreeNode[],
-  projectRoot: string,
-  ig: Ignore,
-  gitMap: Map<string, string>,
-  showHidden: boolean,
-): TreeNode[] {
-  return nodes.map((node) => {
-    const updated: TreeNode = {
-      ...node,
-      gitStatus: gitMap.get(node.entry.path) ?? null,
-    };
-    if (node.expanded && node.entry.isDir) {
-      const freshChildren = readDirectory(node.entry.absolutePath, projectRoot, ig, showHidden).map(
-        (entry) => ({
-          entry,
-          expanded: false,
-          children: [],
-          depth: node.depth + 1,
-          gitStatus: gitMap.get(entry.path) ?? null,
-        }),
-      );
-      // Preserve expanded state of children that still exist
-      const oldByPath = new Map(node.children.map((c) => [c.entry.path, c]));
-      updated.children = freshChildren.map((fresh) => {
-        const old = oldByPath.get(fresh.entry.path);
-        if (old?.expanded && old.entry.isDir) {
-          return {
-            ...fresh,
-            expanded: true,
-            children: refreshExpandedNodes([old], projectRoot, ig, gitMap, showHidden)[0]!.children,
-          };
-        }
-        return fresh;
-      });
-    }
-    return updated;
-  });
-}

package/src/widgets/explorer/tree.tsx

@@ -1,156 +0,0 @@
-import { createMemo, createEffect, For, Show } from "solid-js";
-import { RGBA, type ScrollBoxRenderable } from "@opentui/core";
-import type { TreeNode } from "./tree-model.ts";
-import type { WidgetTheme } from "../lib/theme.ts";
-
-function toRGBA(c: { r: number; g: number; b: number; a: number }): RGBA {
-  return RGBA.fromInts(c.r, c.g, c.b, c.a);
-}
-
-const TRANSPARENT = RGBA.fromInts(0, 0, 0, 0);
-
-function getStatusLabel(status: string): string {
-  switch (status) {
-    case "M":
-      return " M";
-    case "A":
-      return " A";
-    case "D":
-      return " D";
-    case "?":
-      return " ?";
-    default:
-      return "";
-  }
-}
-
-function getStatusColor(
-  status: string,
-  theme: WidgetTheme,
-): { r: number; g: number; b: number; a: number } {
-  switch (status) {
-    case "M":
-      return theme.gitModified;
-    case "A":
-      return theme.gitAdded;
-    case "D":
-      return theme.gitDeleted;
-    case "?":
-      return theme.gitUntracked;
-    default:
-      return theme.fgMuted;
-  }
-}
-
-function getNameColor(
-  name: string,
-  isDir: boolean,
-  isSelected: boolean,
-  isIgnored: boolean,
-  theme: WidgetTheme,
-): { r: number; g: number; b: number; a: number } {
-  if (isSelected) return theme.selectedText;
-  if (isIgnored) return theme.ignored;
-  if (isDir) return theme.dirName;
-  if (name.endsWith(".lock") || name.startsWith(".") || name === "LICENSE") {
-    return theme.fgMuted;
-  }
-  return theme.fg;
-}
-
-interface FileTreeProps {
-  nodes: TreeNode[];
-  selected: number;
-  theme: WidgetTheme;
-  inputMode: "keyboard" | "mouse";
-  onSelect: (index: number) => void;
-  onActivate: (node: TreeNode) => void;
-  onInputModeChange: (mode: "keyboard" | "mouse") => void;
-}
-
-export function FileTree(props: FileTreeProps) {
-  let scroll: ScrollBoxRenderable | undefined;
-
-  createEffect(() => {
-    const idx = props.selected;
-    if (!scroll) return;
-    const children = scroll.getChildren();
-    const target = children[idx];
-    if (!target) return;
-    const y = target.y - scroll.y;
-    if (y >= scroll.height) scroll.scrollBy(y - scroll.height + 1);
-    if (y < 0) scroll.scrollBy(y);
-  });
-
-  return (
-    <scrollbox
-      ref={(r: ScrollBoxRenderable) => (scroll = r)}
-      flexGrow={1}
-      verticalScrollbarOptions={{
-        trackOptions: {
-          backgroundColor: toRGBA(props.theme.bg),
-          foregroundColor: toRGBA(props.theme.accent),
-        },
-      }}
-    >
-      <For each={props.nodes}>
-        {(node, index) => {
-          const isSelected = createMemo(() => index() === props.selected);
-          const icon = node.entry.isDir ? "> " : "  ";
-          const nameColor = () =>
-            getNameColor(
-              node.entry.name,
-              node.entry.isDir,
-              isSelected(),
-              node.entry.ignored,
-              props.theme,
-            );
-          const rowBg = () =>
-            isSelected()
-              ? toRGBA(props.theme.selected)
-              : index() % 2 === 1
-                ? toRGBA(props.theme.rowAlt)
-                : TRANSPARENT;
-
-          return (
-            <box
-              id={String(index())}
-              backgroundColor={rowBg()}
-              flexDirection="row"
-              paddingLeft={1}
-              paddingRight={1}
-              onMouseMove={() => {
-                props.onInputModeChange("mouse");
-                props.onSelect(index());
-              }}
-              onMouseDown={() => props.onSelect(index())}
-              onMouseUp={() => {
-                props.onActivate(node);
-              }}
-            >
-              <text fg={toRGBA(nameColor())} wrapMode="none" flexGrow={1}>
-                {icon}
-                {node.entry.name}
-                {node.entry.isDir ? "/" : ""}
-              </text>
-              <Show when={node.gitStatus}>
-                <text
-                  fg={toRGBA(getStatusColor(node.gitStatus!, props.theme))}
-                  flexShrink={0}
-                  wrapMode="none"
-                >
-                  {getStatusLabel(node.gitStatus!)}
-                </text>
-              </Show>
-              <Show when={isSelected() && !node.entry.isDir}>
-                <text fg={toRGBA(props.theme.fgMuted)} flexShrink={0} wrapMode="none">
-                  {" c: send to claude code"}
-                </text>
-              </Show>
-            </box>
-          );
-        }}
-      </For>
-    </scrollbox>
-  );
-}

package/src/widgets/lib/config-model.ts

@@ -1,116 +0,0 @@
-import { IdeConfigSchema, type IdeConfig, type Row } from "../../schemas/ide-config.ts";
-
-// ---------------------------------------------------------------------------
-// Config Tree
-// ---------------------------------------------------------------------------
-
-export interface TreeNode {
-  path: string[];
-  label: string;
-  value: string | null;
-  depth: number;
-  expandable: boolean;
-}
-
-function flattenValue(obj: unknown, path: string[], depth: number, nodes: TreeNode[]): void {
-  if (Array.isArray(obj)) {
-    const label = path[path.length - 1] ?? "";
-    nodes.push({ path: [...path], label, value: null, depth, expandable: true });
-    for (let i = 0; i < obj.length; i++) {
-      flattenValue(obj[i], [...path, String(i)], depth + 1, nodes);
-    }
-  } else if (obj !== null && typeof obj === "object") {
-    const label = path[path.length - 1] ?? "";
-    nodes.push({ path: [...path], label, value: null, depth, expandable: true });
-    for (const [key, val] of Object.entries(obj as Record<string, unknown>)) {
-      flattenValue(val, [...path, key], depth + 1, nodes);
-    }
-  } else {
-    const label = path[path.length - 1] ?? "";
-    nodes.push({
-      path: [...path],
-      label,
-      value: obj === undefined || obj === null ? null : String(obj),
-      depth,
-      expandable: false,
-    });
-  }
-}
-
-export function flattenConfigTree(config: IdeConfig): TreeNode[] {
-  const nodes: TreeNode[] = [];
-  for (const [key, val] of Object.entries(config)) {
-    if (val === undefined) continue;
-    flattenValue(val, [key], 0, nodes);
-  }
-  return nodes;
-}
-
-// ---------------------------------------------------------------------------
-// Config Mutations
-// ---------------------------------------------------------------------------
-
-export function deepClone<T>(obj: T): T {
-  return JSON.parse(JSON.stringify(obj)) as T;
-}
-
-export function updateConfigAtPath(config: IdeConfig, path: string[], value: unknown): IdeConfig {
-  const cloned = deepClone(config);
-  let current: Record<string, unknown> = cloned as unknown as Record<string, unknown>;
-  for (let i = 0; i < path.length - 1; i++) {
-    const key = path[i]!;
-    current = current[key] as Record<string, unknown>;
-  }
-  const lastKey = path[path.length - 1]!;
-  current[lastKey] = value;
-  return cloned;
-}
-
-export function addPane(config: IdeConfig, rowIdx: number): IdeConfig {
-  const cloned = deepClone(config);
-  const row = cloned.rows[rowIdx];
-  if (!row) return cloned;
-  row.panes.push({ title: "New Pane" });
-  return cloned;
-}
-
-export function removePane(config: IdeConfig, rowIdx: number, paneIdx: number): IdeConfig {
-  const cloned = deepClone(config);
-  const row = cloned.rows[rowIdx];
-  if (!row) return cloned;
-  if (row.panes.length <= 1) return cloned;
-  row.panes.splice(paneIdx, 1);
-  return cloned;
-}
-
-export function addRow(config: IdeConfig, size?: string): IdeConfig {
-  const cloned = deepClone(config);
-  const row: Row = { panes: [{ title: "Shell" }] };
-  if (size) row.size = size;
-  cloned.rows.push(row);
-  return cloned;
-}
-
-export function removeRow(config: IdeConfig, rowIdx: number): IdeConfig {
-  const cloned = deepClone(config);
-  if (cloned.rows.length <= 1) return cloned;
-  cloned.rows.splice(rowIdx, 1);
-  return cloned;
-}
-
-// ---------------------------------------------------------------------------
-// Validation
-// ---------------------------------------------------------------------------
-
-export function validateSetupConfig(
-  config: unknown,
-): { valid: true; config: IdeConfig } | { valid: false; errors: string[] } {
-  const result = IdeConfigSchema.safeParse(config);
-  if (result.success) {
-    return { valid: true, config: result.data };
-  }
-  return {
-    valid: false,
-    errors: result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`),
-  };
-}

package/src/widgets/lib/files.test.ts

@@ -1,103 +0,0 @@
-import { describe, it, beforeEach, afterEach, expect } from "bun:test";
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createIgnoreFilter, readDirectory } from "./files.ts";
-
-let tmpDir: string;
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-files-test-"));
-});
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-describe("readDirectory", () => {
-  it("returns sorted entries with directories first", () => {
-    mkdirSync(join(tmpDir, "beta-dir"));
-    mkdirSync(join(tmpDir, "alpha-dir"));
-    writeFileSync(join(tmpDir, "zebra.txt"), "");
-    writeFileSync(join(tmpDir, "apple.txt"), "");
-    const ig = createIgnoreFilter(tmpDir);
-    const entries = readDirectory(tmpDir, tmpDir, ig, false);
-    const names = entries.map((e) => e.name);
-    expect(names).toEqual(["alpha-dir", "beta-dir", "apple.txt", "zebra.txt"]);
-  });
-
-  it("marks directories and files correctly", () => {
-    mkdirSync(join(tmpDir, "subdir"));
-    writeFileSync(join(tmpDir, "file.txt"), "");
-    const ig = createIgnoreFilter(tmpDir);
-    const entries = readDirectory(tmpDir, tmpDir, ig, false);
-    const dir = entries.find((e) => e.name === "subdir");
-    const file = entries.find((e) => e.name === "file.txt");
-    expect(dir?.isDir).toBe(true);
-    expect(file?.isDir).toBe(false);
-  });
-
-  it("filters ALWAYS_IGNORE entries like node_modules and .git", () => {
-    mkdirSync(join(tmpDir, "node_modules"));
-    mkdirSync(join(tmpDir, ".git"));
-    mkdirSync(join(tmpDir, "src"));
-    writeFileSync(join(tmpDir, "file.txt"), "");
-    const ig = createIgnoreFilter(tmpDir);
-    const entries = readDirectory(tmpDir, tmpDir, ig, false);
-    const names = entries.map((e) => e.name);
-    expect(!names.includes("node_modules")).toBeTruthy();
-    expect(!names.includes(".git")).toBeTruthy();
-    expect(names.includes("src")).toBeTruthy();
-    expect(names.includes("file.txt")).toBeTruthy();
-  });
-
-  it("respects .gitignore patterns", () => {
-    writeFileSync(join(tmpDir, ".gitignore"), "*.log\nbuild/\n");
-    writeFileSync(join(tmpDir, "app.log"), "log data");
-    writeFileSync(join(tmpDir, "main.ts"), "code");
-    mkdirSync(join(tmpDir, "build"));
-    const ig = createIgnoreFilter(tmpDir);
-    const entries = readDirectory(tmpDir, tmpDir, ig, true); // showHidden to see .gitignore
-    const names = entries.map((e) => e.name);
-    expect(!names.includes("app.log")).toBeTruthy();
-    expect(!names.includes("build")).toBeTruthy();
-    expect(names.includes("main.ts")).toBeTruthy();
-  });
-
-  it("hides hidden files when showHidden is false", () => {
-    writeFileSync(join(tmpDir, ".hidden"), "");
-    writeFileSync(join(tmpDir, "visible.txt"), "");
-    const ig = createIgnoreFilter(tmpDir);
-    const entries = readDirectory(tmpDir, tmpDir, ig, false);
-    const names = entries.map((e) => e.name);
-    expect(!names.includes(".hidden")).toBeTruthy();
-    expect(names.includes("visible.txt")).toBeTruthy();
-  });
-
-  it("shows hidden files when showHidden is true", () => {
-    writeFileSync(join(tmpDir, ".hidden"), "");
-    writeFileSync(join(tmpDir, "visible.txt"), "");
-    const ig = createIgnoreFilter(tmpDir);
-    const entries = readDirectory(tmpDir, tmpDir, ig, true);
-    const names = entries.map((e) => e.name);
-    expect(names.includes(".hidden")).toBeTruthy();
-    expect(names.includes("visible.txt")).toBeTruthy();
-  });
-
-  it("returns empty array for non-existent directory", () => {
-    const ig = createIgnoreFilter(tmpDir);
-    const entries = readDirectory(join(tmpDir, "nonexistent"), tmpDir, ig, false);
-    expect(entries).toEqual([]);
-  });
-
-  it("provides correct relative and absolute paths", () => {
-    mkdirSync(join(tmpDir, "src"));
-    writeFileSync(join(tmpDir, "src", "file.ts"), "");
-    const ig = createIgnoreFilter(tmpDir);
-    const entries = readDirectory(join(tmpDir, "src"), tmpDir, ig, false);
-    const file = entries.find((e) => e.name === "file.ts");
-    expect(file).toBeTruthy();
-    expect(file.path).toBe("src/file.ts");
-    expect(file.absolutePath).toBe(join(tmpDir, "src", "file.ts"));
-  });
-});