Add VS Code file icons and tighten workspace entry filtering

- render theme-aware VS Code icons for path suggestions in chat composer - exclude `.convex` and gitignored paths more reliably in workspace indexing - add tests plus a sync script and icon manifest/association data

Julius Marminge committed 8 months ago

Commit f04b2d91 parent 3109d1a9 files · +558 −51Browse files

Showing the changes to apps/server/src (2 of 9 files). Show all

Unified · Split

2 files

apps/server/src/workspaceEntries.test.ts +47 −16
apps/server/src/workspaceEntries.ts +74 −12

apps/server/src/workspaceEntries.test.ts+47−16

 import path from "node:path";
 import { spawnSync } from "node:child_process";
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, assert, describe, it } from "vitest";
 import { searchWorkspaceEntries } from "./workspaceEntries";
     const result = await searchWorkspaceEntries({ cwd, query: "", limit: 100 });
     const paths = result.entries.map((entry) => entry.path);
-    expect(paths).toContain("src");
+    assert.include(paths, "src");
-    expect(paths).toContain("src/components");
+    assert.include(paths, "src/components");
-    expect(paths).toContain("src/components/Composer.tsx");
+    assert.include(paths, "src/components/Composer.tsx");
-    expect(paths).toContain("README.md");
+    assert.include(paths, "README.md");
-    expect(paths.some((entryPath) => entryPath.startsWith(".git"))).toBe(false);
+    assert.isFalse(paths.some((entryPath) => entryPath.startsWith(".git")));
-    expect(paths.some((entryPath) => entryPath.startsWith("node_modules"))).toBe(false);
+    assert.isFalse(paths.some((entryPath) => entryPath.startsWith("node_modules")));
-    expect(result.truncated).toBe(false);
+    assert.isFalse(result.truncated);
   });
   it("filters and ranks entries by query", async () => {
     const result = await searchWorkspaceEntries({ cwd, query: "compo", limit: 5 });
-    expect(result.entries.length).toBeGreaterThan(0);
+    assert.isAbove(result.entries.length, 0);
-    expect(result.entries.some((entry) => entry.path === "src/components")).toBe(true);
+    assert.isTrue(result.entries.some((entry) => entry.path === "src/components"));
-    expect(result.entries.every((entry) => entry.path.toLowerCase().includes("compo"))).toBe(true);
+    assert.isTrue(result.entries.every((entry) => entry.path.toLowerCase().includes("compo")));
   });
   it("excludes gitignored paths for git repositories", async () => {
     const cwd = makeTempDir("t3code-workspace-gitignore-");
     runGit(cwd, ["init"]);
-    writeFile(cwd, ".gitignore", ".convex/\nignored.txt\n");
+    writeFile(cwd, ".gitignore", ".convex/\nconvex/\nignored.txt\n");
     writeFile(cwd, "src/keep.ts", "export {};");
     writeFile(cwd, "ignored.txt", "ignore me");
     writeFile(cwd, ".convex/local-storage/data.json", "{}");
+    writeFile(cwd, "convex/UOoS-l/convex_local_storage/modules/data.json", "{}");
     const result = await searchWorkspaceEntries({ cwd, query: "", limit: 100 });
     const paths = result.entries.map((entry) => entry.path);
-    expect(paths).toContain("src");
+    assert.include(paths, "src");
-    expect(paths).toContain("src/keep.ts");
+    assert.include(paths, "src/keep.ts");
-    expect(paths).not.toContain("ignored.txt");
+    assert.notInclude(paths, "ignored.txt");
-    expect(paths.some((entryPath) => entryPath.startsWith(".convex/"))).toBe(false);
+    assert.isFalse(paths.some((entryPath) => entryPath.startsWith(".convex/")));
+    assert.isFalse(paths.some((entryPath) => entryPath.startsWith("convex/")));
+  });
+  it("excludes tracked paths that match ignore rules", async () => {
+    const cwd = makeTempDir("t3code-workspace-tracked-gitignore-");
+    runGit(cwd, ["init"]);
+    writeFile(cwd, ".convex/local-storage/data.json", "{}");
+    writeFile(cwd, "src/keep.ts", "export {};");
+    runGit(cwd, ["add", ".convex/local-storage/data.json", "src/keep.ts"]);
+    writeFile(cwd, ".gitignore", ".convex/\n");
+    const result = await searchWorkspaceEntries({ cwd, query: "", limit: 100 });
+    const paths = result.entries.map((entry) => entry.path);
+    assert.include(paths, "src");
+    assert.include(paths, "src/keep.ts");
+    assert.isFalse(paths.some((entryPath) => entryPath.startsWith(".convex/")));
+  });
+  it("excludes .convex in non-git workspaces", async () => {
+    const cwd = makeTempDir("t3code-workspace-non-git-convex-");
+    writeFile(cwd, ".convex/local-storage/data.json", "{}");
+    writeFile(cwd, "src/keep.ts", "export {};");
+    const result = await searchWorkspaceEntries({ cwd, query: "", limit: 100 });
+    const paths = result.entries.map((entry) => entry.path);
+    assert.include(paths, "src");
+    assert.include(paths, "src/keep.ts");
+    assert.isFalse(paths.some((entryPath) => entryPath.startsWith(".convex/")));
   });
 });

apps/server/src/workspaceEntries.ts+74−12

 import fs from "node:fs/promises";
+import type { Dirent } from "node:fs";
 import path from "node:path";
 import { runProcess } from "./processRunner";
 const WORKSPACE_INDEX_MAX_ENTRIES = 25_000;
 const IGNORED_DIRECTORY_NAMES = new Set([
   ".git",
+  ".convex",
   "node_modules",
   ".next",
   ".turbo",
   return directories;
 }
-async function buildWorkspaceIndexFromGit(cwd: string): Promise<WorkspaceIndex | null> {
+async function isInsideGitWorkTree(cwd: string): Promise<boolean> {
   const insideWorkTree = await runProcess("git", ["rev-parse", "--is-inside-work-tree"], {
     cwd,
     allowNonZeroExit: true,
     timeoutMs: 5_000,
     maxBufferBytes: 4_096,
   }).catch(() => null);
-  if (!insideWorkTree || insideWorkTree.code !== 0 || insideWorkTree.stdout.trim() !== "true") {
+  return Boolean(
+    insideWorkTree && insideWorkTree.code === 0 && insideWorkTree.stdout.trim() === "true",
+  );
+}
+async function filterGitIgnoredPaths(cwd: string, relativePaths: string[]): Promise<string[]> {
+  if (relativePaths.length === 0) {
+    return relativePaths;
+  }
+  const checkIgnore = await runProcess("git", ["check-ignore", "--no-index", "-z", "--stdin"], {
+    cwd,
+    allowNonZeroExit: true,
+    timeoutMs: 20_000,
+    maxBufferBytes: 16 * 1024 * 1024,
+    outputMode: "truncate",
+    stdin: `${relativePaths.join("\0")}\0`,
+  }).catch(() => null);
+  if (!checkIgnore) {
+    return relativePaths;
+  }
+  // git-check-ignore exits with 1 when no paths match.
+  if (checkIgnore.code !== 0 && checkIgnore.code !== 1) {
+    return relativePaths;
+  }
+  const ignoredPaths = new Set(
+    splitNullSeparatedPaths(checkIgnore.stdout, Boolean(checkIgnore.stdoutTruncated)),
+  );
+  if (ignoredPaths.size === 0) {
+    return relativePaths;
+  }
+  return relativePaths.filter((relativePath) => !ignoredPaths.has(relativePath));
+}
+async function buildWorkspaceIndexFromGit(cwd: string): Promise<WorkspaceIndex | null> {
+  if (!(await isInsideGitWorkTree(cwd))) {
     return null;
   }
     return null;
   }
-  const filePaths = splitNullSeparatedPaths(listedFiles.stdout, Boolean(listedFiles.stdoutTruncated))
+  const listedPaths = splitNullSeparatedPaths(
+    listedFiles.stdout,
+    Boolean(listedFiles.stdoutTruncated),
+  )
     .map((entry) => toPosixPath(entry))
     .filter((entry) => entry.length > 0 && !isPathInIgnoredDirectory(entry));
+  const filePaths = await filterGitIgnoredPaths(cwd, listedPaths);
   const directorySet = new Set<string>();
   for (const filePath of filePaths) {
   if (gitIndexed) {
     return gitIndexed;
   }
+  const shouldFilterWithGitIgnore = await isInsideGitWorkTree(cwd);
   let pendingDirectories: string[] = [""];
   const entries: ProjectEntry[] = [];
       }),
     );
-    for (const directoryEntry of directoryEntries) {
+    const candidateEntriesByDirectory = directoryEntries.map((directoryEntry) => {
       const { relativeDir, dirents } = directoryEntry;
-      if (!dirents) {
+      if (!dirents) return [] as Array<{ dirent: Dirent; relativePath: string }>;
-        continue;
-      }
       dirents.sort((left, right) => left.name.localeCompare(right.name));
+      const candidates: Array<{ dirent: Dirent; relativePath: string }> = [];
       for (const dirent of dirents) {
         if (!dirent.name || dirent.name === "." || dirent.name === "..") {
           continue;
         if (isPathInIgnoredDirectory(relativePath)) {
           continue;
         }
+        candidates.push({ dirent, relativePath });
+      }
+      return candidates;
+    });
+    const candidatePaths = candidateEntriesByDirectory.flatMap((candidateEntries) =>
+      candidateEntries.map((entry) => entry.relativePath),
+    );
+    const allowedPathSet = shouldFilterWithGitIgnore
+      ? new Set(await filterGitIgnoredPaths(cwd, candidatePaths))
+      : null;
+    for (const candidateEntries of candidateEntriesByDirectory) {
+      for (const candidate of candidateEntries) {
+        if (allowedPathSet && !allowedPathSet.has(candidate.relativePath)) {
+          continue;
+        }
         const entry: ProjectEntry = {
-          path: relativePath,
+          path: candidate.relativePath,
-          kind: dirent.isDirectory() ? "directory" : "file",
+          kind: candidate.dirent.isDirectory() ? "directory" : "file",
-          parentPath: parentPathOf(relativePath),
+          parentPath: parentPathOf(candidate.relativePath),
         };
         entries.push(entry);
-        if (dirent.isDirectory()) {
+        if (candidate.dirent.isDirectory()) {
-          pendingDirectories.push(relativePath);
+          pendingDirectories.push(candidate.relativePath);
         }
         if (entries.length >= WORKSPACE_INDEX_MAX_ENTRIES) {