tmux-ide 1.2.1 → 2.0.0

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

@@ -0,0 +1,214 @@
+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

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,156 @@
+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

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,103 @@
+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"));
+  });
+});