@hienlh/ppm 0.12.7 → 0.12.8

package/src/services/db.service.ts

@@ -3,7 +3,7 @@ import { resolve } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
 import { encrypt, decrypt } from "../lib/account-crypto.ts";
 import { getPpmDir } from "./ppm-dir.ts";
-const CURRENT_SCHEMA_VERSION = 20;
+const CURRENT_SCHEMA_VERSION = 21;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -589,6 +589,16 @@ function runMigrations(database: Database): void {
     }
     database.exec("PRAGMA user_version = 20");
   }
+
+  if (current < 21) {
+    // Add per-project settings JSON column (idempotent: check column existence first)
+    const cols = database.query("PRAGMA table_info(projects)").all() as { name: string }[];
+    const hasSettings = cols.some((c) => c.name === "settings");
+    if (!hasSettings) {
+      database.exec(`ALTER TABLE projects ADD COLUMN settings TEXT DEFAULT '{}'`);
+    }
+    database.exec("PRAGMA user_version = 21");
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -668,6 +678,52 @@ export function deleteProject(nameOrPath: string): void {
   getDb().query("DELETE FROM projects WHERE name = ? OR path = ?").run(nameOrPath, nameOrPath);
 }
 
+/** Get per-project settings JSON string (returns '{}' if missing or null) */
+export function getProjectSettingsJson(projectPath: string): string {
+  const row = getDb().query("SELECT settings FROM projects WHERE path = ?").get(projectPath) as { settings: string | null } | null;
+  return row?.settings ?? "{}";
+}
+
+/** Patch per-project settings JSON (deep merge — plain-object values are merged one level deep) */
+export function patchProjectSettingsJson(projectPath: string, patch: string): void {
+  const existing = getProjectSettingsJson(projectPath);
+
+  let existingObj: Record<string, unknown>;
+  let patchObj: Record<string, unknown>;
+  try { existingObj = (JSON.parse(existing) ?? {}) as Record<string, unknown>; }
+  catch { existingObj = {}; }
+  try { patchObj = JSON.parse(patch) as Record<string, unknown>; }
+  catch { throw new Error("Invalid patch JSON"); }
+
+  if (typeof patchObj !== "object" || patchObj === null || Array.isArray(patchObj)) {
+    throw new Error("Patch must be a plain object");
+  }
+
+  // One-level deep merge: if both sides have a plain-object value, shallow-merge; else replace
+  const merged: Record<string, unknown> = { ...existingObj };
+  for (const key of Object.keys(patchObj)) {
+    const pv = patchObj[key];
+    const ev = existingObj[key];
+    if (isPlainObject(pv) && isPlainObject(ev)) {
+      merged[key] = { ...(ev as Record<string, unknown>), ...(pv as Record<string, unknown>) };
+    } else {
+      merged[key] = pv;
+    }
+  }
+
+  const result = getDb()
+    .query("UPDATE projects SET settings = ? WHERE path = ?")
+    .run(JSON.stringify(merged), projectPath);
+
+  if ((result as { changes: number }).changes === 0) {
+    throw new Error(`Project not found: ${projectPath}`);
+  }
+}
+
+function isPlainObject(v: unknown): boolean {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
+}
+
 export function updateProject(currentName: string, newName: string, newPath: string, color?: string | null): void {
   getDb().query(
     "UPDATE projects SET name = ?, path = ?, color = ? WHERE name = ?",

package/src/services/file-filter.service.ts

@@ -0,0 +1,121 @@
+/**
+ * file-filter.service.ts
+ * Resolves VS Code-style file exclude patterns for lazy-load file tree.
+ * Precedence: hardcoded defaults < global config < per-project override (last wins).
+ */
+
+import type { FileFilterConfig } from "../types/project.ts";
+import { configService } from "./config.service.ts";
+
+/** Patterns always excluded from tree listing (cannot be overridden by config) */
+export const HARDCODED_FILES_EXCLUDE = [
+  "**/.git",
+  "**/.DS_Store",
+  "**/Thumbs.db",
+];
+
+/** Patterns always excluded from index/search */
+export const HARDCODED_SEARCH_EXCLUDE = [
+  "**/node_modules",
+  "**/dist",
+  "**/build",
+  "**/.next",
+  "**/target",
+  "**/.venv",
+  "**/.cache",
+];
+
+export interface ResolvedFilter {
+  /** Combined filesExclude: hardcoded + global + project (deduped) */
+  filesExclude: string[];
+  /** Combined searchExclude: hardcoded + global + project (deduped) */
+  searchExclude: string[];
+  /** Whether to apply gitignore rules */
+  useIgnoreFiles: boolean;
+}
+
+/**
+ * Resolve final filter config for a project path.
+ * Merges: hardcoded defaults ∪ global config ∪ per-project override.
+ */
+export function resolveFilter(projectPath: string): ResolvedFilter {
+  const globalFilesExclude = configService.getFilesExclude();
+  const globalSearchExclude = configService.getSearchExclude();
+  const globalUseIgnoreFiles = configService.getUseIgnoreFiles();
+
+  const projectSettings = configService.getProjectSettings(projectPath);
+  const projectFilter: FileFilterConfig = projectSettings.files ?? {};
+
+  // Merge arrays (dedup)
+  const filesExclude = dedup([
+    ...HARDCODED_FILES_EXCLUDE,
+    ...globalFilesExclude,
+    ...(projectFilter.filesExclude ?? []),
+  ]);
+
+  const searchExclude = dedup([
+    ...HARDCODED_SEARCH_EXCLUDE,
+    ...globalSearchExclude,
+    ...(projectFilter.searchExclude ?? []),
+  ]);
+
+  // Per-project useIgnoreFiles overrides global if set
+  const useIgnoreFiles = projectFilter.useIgnoreFiles !== undefined
+    ? projectFilter.useIgnoreFiles
+    : globalUseIgnoreFiles;
+
+  return { filesExclude, searchExclude, useIgnoreFiles };
+}
+
+function dedup(arr: string[]): string[] {
+  return [...new Set(arr)];
+}
+
+/**
+ * Check if a relative path matches any of the given glob patterns.
+ * Uses simple pattern-to-regex conversion (no external lib needed).
+ * Patterns follow VS Code glob semantics: ** crosses dirs, * stays in one segment.
+ */
+export function matchesGlob(relPath: string, patterns: string[]): boolean {
+  // Normalize path separators to forward slash
+  const normalized = relPath.split("\\").join("/");
+  return patterns.some((pattern) => matchSingleGlob(normalized, pattern));
+}
+
+function matchSingleGlob(relPath: string, pattern: string): boolean {
+  // Strip leading **/ for simpler matching — handled by regex
+  const re = globPatternToRegex(pattern);
+  return re.test(relPath);
+}
+
+/**
+ * Convert a VS Code-style glob pattern to a RegExp.
+ * Cached per unique pattern string for performance.
+ */
+const regexCache = new Map<string, RegExp>();
+
+function globPatternToRegex(pattern: string): RegExp {
+  const cached = regexCache.get(pattern);
+  if (cached) return cached;
+
+  let p = pattern;
+  // Normalize path separators
+  p = p.split("\\").join("/");
+  // Strip leading ./
+  if (p.startsWith("./")) p = p.slice(2);
+
+  const escaped = p
+    .replace(/[.+^${}()|[\]]/g, "\\$&") // escape regex special chars (not * ?)
+    .replace(/\*\*/g, "\x00")            // temp: ** placeholder
+    .replace(/\*/g, "[^/]*")             // * = within one path segment
+    .replace(/\x00/g, ".*")             // ** = any path
+    .replace(/\?/g, "[^/]");            // ? = single non-slash char
+
+  // Pattern with no slash (e.g. *.log) → match at any depth
+  const re = p.includes("/")
+    ? new RegExp(`^${escaped}(/|$)`)
+    : new RegExp(`(^|/)${escaped}(/|$)`);
+
+  regexCache.set(pattern, re);
+  return re;
+}

package/src/services/file-list-index.service.ts

@@ -0,0 +1,170 @@
+/**
+ * file-list-index.service.ts
+ * Lazy-load file tree listing and flat index building for palette/search.
+ * Implements listDir() (1-level) and buildIndex() (recursive) with filter support.
+ * Index results are cached per project path and invalidated on file changes.
+ */
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { resolve, relative, join } from "node:path";
+import ignore, { type Ignore } from "ignore";
+import type { FileEntry, FileDirEntry } from "../types/project.ts";
+import { matchesGlob, resolveFilter } from "./file-filter.service.ts";
+import { SecurityError, NotFoundError } from "./file.service.ts";
+
+// ---------------------------------------------------------------------------
+// Index cache keyed by absolute project path
+// ---------------------------------------------------------------------------
+
+const indexCache = new Map<string, FileEntry[]>();
+
+/** Invalidate cached flat index for a project (called on file change events) */
+export function invalidateIndexCache(projectPath: string): void {
+  indexCache.delete(projectPath);
+}
+
+/** Clear all cached indexes (e.g. for tests) */
+export function clearIndexCache(): void {
+  indexCache.clear();
+}
+
+// ---------------------------------------------------------------------------
+// Gitignore loader (shared utility)
+// ---------------------------------------------------------------------------
+
+function loadGitignore(projectPath: string): Ignore {
+  const ig = ignore();
+  const gitignorePath = join(projectPath, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    try {
+      const content = readFileSync(gitignorePath, "utf-8");
+      ig.add(content);
+    } catch { /* unreadable — skip */ }
+  }
+  return ig;
+}
+
+// ---------------------------------------------------------------------------
+// Path traversal guard
+// ---------------------------------------------------------------------------
+
+function assertWithinProject(relPath: string, projectPath: string): void {
+  const abs = resolve(projectPath, relPath);
+  if (!abs.startsWith(projectPath + "/") && abs !== projectPath) {
+    throw new SecurityError("Path traversal not allowed");
+  }
+}
+
+// ---------------------------------------------------------------------------
+// listDir — single directory level
+// ---------------------------------------------------------------------------
+
+/**
+ * List one directory level for lazy-load file tree.
+ * Applies filesExclude patterns from resolved filter.
+ * Marks entries as isIgnored based on .gitignore (informational — still listed).
+ */
+export function listDir(projectPath: string, relPath: string): FileDirEntry[] {
+  if (relPath) assertWithinProject(relPath, projectPath);
+
+  const absDir = relPath ? resolve(projectPath, relPath) : projectPath;
+  if (!existsSync(absDir)) throw new NotFoundError(`Directory not found: ${relPath || "/"}`);
+
+  const filter = resolveFilter(projectPath);
+  const ig = filter.useIgnoreFiles ? loadGitignore(projectPath) : null;
+
+  let rawEntries;
+  try { rawEntries = readdirSync(absDir, { withFileTypes: true }); }
+  catch { return []; }
+
+  const results: FileDirEntry[] = [];
+
+  for (const entry of rawEntries) {
+    const entryRel = relPath ? `${relPath}/${entry.name}` : entry.name;
+    const entryRelPosix = entryRel.split("\\").join("/");
+
+    // Skip entries matching filesExclude (check full path and bare name)
+    if (matchesGlob(entryRelPosix, filter.filesExclude)) continue;
+    if (matchesGlob(entry.name, filter.filesExclude)) continue;
+
+    // Gitignore flag (informational only — entry still included in list)
+    let isIgnored = false;
+    if (ig) {
+      const checkPath = entry.isDirectory() ? `${entryRelPosix}/` : entryRelPosix;
+      isIgnored = ig.ignores(checkPath) || ig.ignores(entryRelPosix);
+    }
+
+    results.push({
+      name: entry.name,
+      type: entry.isDirectory() ? "directory" : "file",
+      isIgnored,
+    });
+  }
+
+  // Sort: directories first, then alphabetically
+  results.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+
+  return results;
+}
+
+// ---------------------------------------------------------------------------
+// buildIndex — recursive flat file list
+// ---------------------------------------------------------------------------
+
+/**
+ * Build flat index of all files in project for palette/search.
+ * Applies filesExclude + searchExclude + optional gitignore.
+ * Result is cached; call invalidateIndexCache(projectPath) to bust.
+ */
+export function buildIndex(projectPath: string): FileEntry[] {
+  const cached = indexCache.get(projectPath);
+  if (cached) return cached;
+
+  const filter = resolveFilter(projectPath);
+  const ig = filter.useIgnoreFiles ? loadGitignore(projectPath) : null;
+  const allExclude = [...filter.filesExclude, ...filter.searchExclude];
+
+  const entries: FileEntry[] = [];
+  walkForIndex(projectPath, projectPath, allExclude, ig, entries);
+
+  indexCache.set(projectPath, entries);
+  return entries;
+}
+
+function walkForIndex(
+  rootPath: string,
+  dirPath: string,
+  allExclude: string[],
+  ig: Ignore | null,
+  results: FileEntry[],
+): void {
+  let dirEntries;
+  try { dirEntries = readdirSync(dirPath, { withFileTypes: true }); }
+  catch { return; }
+
+  for (const entry of dirEntries) {
+    const fullPath = join(dirPath, entry.name);
+    const relPath = relative(rootPath, fullPath);
+    const relPosix = relPath.split("\\").join("/");
+
+    // Apply glob exclusion (check full relative path and bare entry name)
+    if (matchesGlob(relPosix, allExclude)) continue;
+    if (matchesGlob(entry.name, allExclude)) continue;
+
+    // Apply gitignore rules
+    if (ig) {
+      const checkPath = entry.isDirectory() ? `${relPosix}/` : relPosix;
+      if (ig.ignores(checkPath) || ig.ignores(relPosix)) continue;
+    }
+
+    if (entry.isDirectory()) {
+      results.push({ path: relPosix, name: entry.name, type: "directory" });
+      walkForIndex(rootPath, fullPath, allExclude, ig, results);
+    } else {
+      results.push({ path: relPosix, name: entry.name, type: "file" });
+    }
+  }
+}

package/src/services/file-watcher.service.ts

@@ -16,11 +16,12 @@ interface WatchEntry {
 }
 
 const watchers = new Map<string, WatchEntry>();
-let changeCallback: ChangeCallback | null = null;
+/** Multiple callbacks supported — each is invoked on every file change event */
+const changeCallbacks: ChangeCallback[] = [];
 
-/** Register callback for file change events */
+/** Register a callback for file change events (additive — does not replace previous) */
 export function onFileChange(cb: ChangeCallback): void {
-  changeCallback = cb;
+  changeCallbacks.push(cb);
 }
 
 function shouldIgnore(filePath: string): boolean {
@@ -47,7 +48,10 @@ export function startWatching(projectName: string, projectPath: string): void {
       entry.timer = setTimeout(() => {
         const paths = [...entry.pending];
         entry.pending.clear();
-        for (const p of paths) changeCallback?.(projectName, p.replaceAll("\\", "/"));
+        for (const p of paths) {
+          const relPath = p.replaceAll("\\", "/");
+          for (const cb of changeCallbacks) cb(projectName, relPath);
+        }
       }, DEBOUNCE_MS);
     });
 

package/src/services/file.service.ts

@@ -9,11 +9,19 @@ import {
   rmSync,
   renameSync,
 } from "node:fs";
-import { resolve, relative, basename, dirname, join, normalize, sep } from "node:path";
+import { resolve, relative, dirname, join, normalize, sep } from "node:path";
 import ignore, { type Ignore } from "ignore";
-import type { FileNode } from "../types/project.ts";
+import type { FileNode, FileEntry, FileDirEntry } from "../types/project.ts";
+import {
+  listDir as listDirImpl,
+  buildIndex as buildIndexImpl,
+  invalidateIndexCache,
+  clearIndexCache,
+} from "./file-list-index.service.ts";
+
+export { invalidateIndexCache, clearIndexCache };
 
-/** Directories/files excluded from tree listing */
+/** Directories/files excluded from tree listing (legacy — kept for getTree back-compat) */
 const EXCLUDED_NAMES = new Set([".git", "node_modules"]);
 
 /** Load and compile gitignore rules from a project root */
@@ -103,13 +111,7 @@ class FileService {
         };
 
         if (entry.isDirectory()) {
-          node.children = this.buildTree(
-            rootPath,
-            fullPath,
-            currentDepth + 1,
-            maxDepth,
-            ig,
-          );
+          node.children = this.buildTree(rootPath, fullPath, currentDepth + 1, maxDepth, ig);
         }
 
         nodes.push(node);
@@ -170,21 +172,14 @@ class FileService {
   }
 
   /** Read file content with encoding detection */
-  readFile(
-    projectPath: string,
-    filePath: string,
-  ): { content: string; encoding: string } {
+  readFile(projectPath: string, filePath: string): { content: string; encoding: string } {
     const absPath = this.resolveSafe(projectPath, filePath);
     this.blockSensitive(filePath);
 
-    if (!existsSync(absPath)) {
-      throw new NotFoundError(`File not found: ${filePath}`);
-    }
+    if (!existsSync(absPath)) throw new NotFoundError(`File not found: ${filePath}`);
 
     const stat = statSync(absPath);
-    if (stat.isDirectory()) {
-      throw new ValidationError("Cannot read a directory");
-    }
+    if (stat.isDirectory()) throw new ValidationError("Cannot read a directory");
 
     // Binary detection: check for null bytes in first chunk
     const buffer = readFileSync(absPath);
@@ -201,27 +196,18 @@ class FileService {
     const absPath = this.resolveSafe(projectPath, filePath);
     this.blockSensitive(filePath);
 
-    // Ensure parent directory exists
     const dir = dirname(absPath);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 
     writeFileSync(absPath, content, "utf-8");
   }
 
   /** Create a file or directory */
-  createFile(
-    projectPath: string,
-    filePath: string,
-    type: "file" | "directory",
-  ): void {
+  createFile(projectPath: string, filePath: string, type: "file" | "directory"): void {
     const absPath = this.resolveSafe(projectPath, filePath);
     this.blockSensitive(filePath);
 
-    if (existsSync(absPath)) {
-      throw new ValidationError(`Already exists: ${filePath}`);
-    }
+    if (existsSync(absPath)) throw new ValidationError(`Already exists: ${filePath}`);
 
     if (type === "directory") {
       mkdirSync(absPath, { recursive: true });
@@ -237,9 +223,7 @@ class FileService {
     const absPath = this.resolveSafe(projectPath, filePath);
     this.blockSensitive(filePath);
 
-    if (!existsSync(absPath)) {
-      throw new NotFoundError(`Not found: ${filePath}`);
-    }
+    if (!existsSync(absPath)) throw new NotFoundError(`Not found: ${filePath}`);
 
     const stat = statSync(absPath);
     if (stat.isDirectory()) {
@@ -250,24 +234,15 @@ class FileService {
   }
 
   /** Rename a file or directory */
-  renameFile(
-    projectPath: string,
-    oldPath: string,
-    newPath: string,
-  ): void {
+  renameFile(projectPath: string, oldPath: string, newPath: string): void {
     const absOld = this.resolveSafe(projectPath, oldPath);
     const absNew = this.resolveSafe(projectPath, newPath);
     this.blockSensitive(oldPath);
     this.blockSensitive(newPath);
 
-    if (!existsSync(absOld)) {
-      throw new NotFoundError(`Not found: ${oldPath}`);
-    }
-    if (existsSync(absNew)) {
-      throw new ValidationError(`Already exists: ${newPath}`);
-    }
+    if (!existsSync(absOld)) throw new NotFoundError(`Not found: ${oldPath}`);
+    if (existsSync(absNew)) throw new ValidationError(`Already exists: ${newPath}`);
 
-    // Ensure parent dir of new path exists
     const dir = dirname(absNew);
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 
@@ -275,15 +250,26 @@ class FileService {
   }
 
   /** Move a file or directory to a new location */
-  moveFile(
-    projectPath: string,
-    source: string,
-    destination: string,
-  ): void {
-    // Move is functionally the same as rename
+  moveFile(projectPath: string, source: string, destination: string): void {
     this.renameFile(projectPath, source, destination);
   }
 
+  /**
+   * List one directory level for lazy-load file tree (delegates to file-list-index.service).
+   * Applies filesExclude patterns; returns gitignore flag per entry.
+   */
+  listDir(projectPath: string, relPath: string): FileDirEntry[] {
+    return listDirImpl(projectPath, relPath);
+  }
+
+  /**
+   * Build flat file index for palette/search (delegates to file-list-index.service).
+   * Cached per project; invalidated on file change via invalidateIndexCache().
+   */
+  buildIndex(projectPath: string): FileEntry[] {
+    return buildIndexImpl(projectPath);
+  }
+
   /** Block access to sensitive paths (.git/) */
   private blockSensitive(filePath: string): void {
     const normalized = normalize(filePath);
@@ -319,3 +305,19 @@ export class ValidationError extends Error {
 }
 
 export const fileService = new FileService();
+
+// Wire file watcher → index cache invalidation
+// Dynamic import avoids circular dependency (file-watcher → chat.ts → file.service)
+import("./file-watcher.service.ts").then(({ onFileChange }) => {
+  onFileChange((projectName) => {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { configService } = require("./config.service.ts");
+      const projects = configService.get("projects") as Array<{ name: string; path: string }>;
+      const project = projects.find((p: { name: string }) => p.name === projectName);
+      if (project) invalidateIndexCache(project.path);
+    } catch {
+      // Config not yet loaded or project not found — skip invalidation
+    }
+  });
+}).catch(() => { /* file-watcher unavailable in test/CLI context */ });

package/src/services/upgrade.service.ts

@@ -23,8 +23,8 @@ export function getInstallMethod(): InstallMethod {
 /** Compare two semver strings (ignores pre-release tags). Returns -1 (a < b), 0 (equal), 1 (a > b) */
 export function compareSemver(a: string, b: string): -1 | 0 | 1 {
   // Strip pre-release suffix (e.g. "1.0.0-beta.1" → "1.0.0")
-  const pa = a.split("-")[0].split(".").map(Number);
-  const pb = b.split("-")[0].split(".").map(Number);
+  const pa = (a.split("-")[0] ?? "0").split(".").map(Number);
+  const pb = (b.split("-")[0] ?? "0").split(".").map(Number);
   for (let i = 0; i < 3; i++) {
     const va = pa[i] ?? 0;
     const vb = pb[i] ?? 0;

package/src/types/chat.ts

@@ -132,7 +132,8 @@ export type ChatEvent =
   | { type: "system"; subtype: string }
   | { type: "team_detected"; teamName: string }
   | { type: "team_updated"; teamName: string; team: unknown }
-  | { type: "team_inbox"; teamName: string; agent: string; messages: unknown[] };
+  | { type: "team_inbox"; teamName: string; agent: string; messages: unknown[] }
+  | { type: "session_migrated"; oldSessionId: string; newSessionId: string };
 
 export type ToolApprovalHandler = (
   tool: string,

package/src/types/project.ts

@@ -19,3 +19,34 @@ export interface FileNode {
   /** True if this path is matched by a .gitignore rule */
   ignored?: boolean;
 }
+
+/** A flat file entry returned by /files/index */
+export interface FileEntry {
+  path: string;
+  name: string;
+  type: "file" | "directory";
+}
+
+/** Entry returned by /files/list (single directory level) */
+export interface FileDirEntry {
+  name: string;
+  type: "file" | "directory";
+  /** True if entry is excluded by gitignore (informational — still listed) */
+  isIgnored: boolean;
+}
+
+/** Per-project file filter override (stored in projects.settings JSON) */
+export interface FileFilterConfig {
+  /** Additional glob patterns to exclude from tree/list */
+  filesExclude?: string[];
+  /** Additional glob patterns to exclude from index/search */
+  searchExclude?: string[];
+  /** Whether to use .gitignore rules (null = use global setting) */
+  useIgnoreFiles?: boolean;
+}
+
+/** Per-project settings stored in projects.settings JSON column */
+export interface ProjectSettings {
+  files?: FileFilterConfig;
+  [key: string]: unknown;
+}

package/src/web/components/chat/file-picker.tsx

@@ -10,19 +10,6 @@ interface FilePickerProps {
   visible: boolean;
 }
 
-/** Flatten a FileNode tree into a flat list of files and directories. */
-export function flattenFileTree(nodes: FileNode[]): FileNode[] {
-  const result: FileNode[] = [];
-  function walk(list: FileNode[]) {
-    for (const node of list) {
-      result.push(node);
-      if (node.children) walk(node.children);
-    }
-  }
-  walk(nodes);
-  return result;
-}
-
 export function FilePicker({
   items,
   filter,