feat(web): tag files and directories from anywhere on the filesystem

apps/server/src/workspace/WorkspaceEntries.test.ts

@@ -651,13 +651,63 @@ it.layer(TestLayer, { excludeTestServices: true })("WorkspaceEntries", (it) => {
         expect(result).toEqual({
           parentPath: cwd,
           entries: [
-            { name: "alpha", fullPath: path.join(cwd, "alpha") },
-            { name: "alpine", fullPath: path.join(cwd, "alpine") },
+            { name: "alpha", fullPath: path.join(cwd, "alpha"), kind: "directory" },
+            { name: "alpine", fullPath: path.join(cwd, "alpine"), kind: "directory" },
           ],
         });
       }),
     );
 
+    it.effect("returns requested kinds in directory-first order and applies the limit", () =>
+      Effect.gen(function* () {
+        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
+        const path = yield* Path.Path;
+        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-browse-kinds-" });
+        yield* writeTextFile(cwd, "alpha/index.ts", "export {};\n");
+        yield* writeTextFile(cwd, "zeta/index.ts", "export {};\n");
+        yield* writeTextFile(cwd, "alphabet.txt", "a");
+        yield* writeTextFile(cwd, "beta.txt", "b");
+
+        const result = yield* workspaceEntries.browse({
+          partialPath: yield* appendSeparator(cwd),
+          kinds: ["file", "directory"],
+          limit: 3,
+        });
+        const filteredResult = yield* workspaceEntries.browse({
+          partialPath: path.join(cwd, "b"),
+          kinds: ["file", "directory"],
+          limit: 1,
+        });
+
+        expect(result).toEqual({
+          parentPath: cwd,
+          entries: [
+            { name: "alpha", fullPath: path.join(cwd, "alpha"), kind: "directory" },
+            { name: "zeta", fullPath: path.join(cwd, "zeta"), kind: "directory" },
+            { name: "alphabet.txt", fullPath: path.join(cwd, "alphabet.txt"), kind: "file" },
+          ],
+        });
+        expect(filteredResult.entries).toEqual([
+          { name: "beta.txt", fullPath: path.join(cwd, "beta.txt"), kind: "file" },
+        ]);
+      }),
+    );
+
+    it.effect("returns no entries when no kinds are requested", () =>
+      Effect.gen(function* () {
+        const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
+        const cwd = yield* makeTempDir({ prefix: "t3code-workspace-browse-empty-kinds-" });
+        yield* writeTextFile(cwd, "src/index.ts", "export {};\n");
+
+        const result = yield* workspaceEntries.browse({
+          partialPath: yield* appendSeparator(cwd),
+          kinds: [],
+        });
+
+        expect(result).toEqual({ parentPath: cwd, entries: [] });
+      }),
+    );
+
     it.effect("shows dot directories in directory mode and hidden-prefix mode", () =>
       Effect.gen(function* () {
         const workspaceEntries = yield* WorkspaceEntries.WorkspaceEntries;
@@ -677,7 +727,7 @@ it.layer(TestLayer, { excludeTestServices: true })("WorkspaceEntries", (it) => {
         expect(directoryResult.entries.map((entry) => entry.name)).toEqual([".config", "config"]);
         expect(hiddenPrefixResult).toEqual({
           parentPath: cwd,
-          entries: [{ name: ".config", fullPath: path.join(cwd, ".config") }],
+          entries: [{ name: ".config", fullPath: path.join(cwd, ".config"), kind: "directory" }],
         });
       }),
     );
@@ -696,7 +746,7 @@ it.layer(TestLayer, { excludeTestServices: true })("WorkspaceEntries", (it) => {
 
         expect(result).toEqual({
           parentPath: cwd,
-          entries: [{ name: "packages", fullPath: path.join(cwd, "packages") }],
+          entries: [{ name: "packages", fullPath: path.join(cwd, "packages"), kind: "directory" }],
         });
       }),
     );

apps/server/src/workspace/WorkspaceEntries.ts

@@ -10,6 +10,7 @@ import * as RcMap from "effect/RcMap";
 import * as Schema from "effect/Schema";
 
 import type {
+  FilesystemBrowseEntry,
   FilesystemBrowseInput,
   FilesystemBrowseResult,
   ProjectListEntriesInput,
@@ -216,23 +217,39 @@ export const make = Effect.gen(function* () {
 
       const showHidden = endsWithSeparator || prefix.startsWith(".");
       const lowerPrefix = prefix.toLowerCase();
-      const entries: Array<{ readonly name: string; readonly fullPath: string }> = [];
+      const requestedKinds = new Set(input.kinds ?? ["directory"]);
+      const entries: FilesystemBrowseEntry[] = [];
       for (const dirent of dirents) {
+        const kind = dirent.isDirectory() ? "directory" : dirent.isFile() ? "file" : null;
         if (
-          dirent.isDirectory() &&
+          kind !== null &&
+          requestedKinds.has(kind) &&
           dirent.name.toLowerCase().startsWith(lowerPrefix) &&
           (showHidden || !dirent.name.startsWith("."))
         ) {
           entries.push({
             name: dirent.name,
             fullPath: path.join(parentPath, dirent.name),
+            kind,
           });
         }
       }
 
+      const byName = (left: FilesystemBrowseEntry, right: FilesystemBrowseEntry) =>
+        left.name.localeCompare(right.name);
+      const directories = entries.filter((entry) => entry.kind === "directory").toSorted(byName);
+      const files = entries.filter((entry) => entry.kind !== "directory").toSorted(byName);
+
+      // Truncating the directories-first order would hide every file behind a
+      // large enough set of directories, so each kind keeps a share of the limit.
+      const limit = input.limit ?? directories.length + files.length;
+      const fileCount = Math.min(files.length, Math.max(0, limit - directories.length));
+      const keptFiles = files.slice(0, Math.max(fileCount, Math.min(files.length, limit >> 1)));
+      const keptDirectories = directories.slice(0, limit - keptFiles.length);
+
       return {
         parentPath,
-        entries: entries.toSorted((left, right) => left.name.localeCompare(right.name)),
+        entries: [...keptDirectories, ...keptFiles],
       };
     },
   );