fix: improve file mention suggestions without ripgrep

src/server/app.ts

@@ -84,11 +84,11 @@ export async function buildApp(deps: AppDependencies = {}): Promise<FastifyInsta
   registerGitRoutes(app, projects, workspaces);
   registerTerminalProxyRoutes(app, projects, workspaces);
 
-  app.get<{ Querystring: { cwd?: string; q?: string; kind?: "tracked" | "untracked" | "other"; mode?: "file" | "path" } }>("/api/files", async (request, reply) => {
+  app.get<{ Querystring: { cwd?: string; q?: string; kind?: "tracked" | "untracked" | "other"; mode?: "file" | "path"; scope?: "tracked" | "all" } }>("/api/files", async (request, reply) => {
     if (request.query.cwd === undefined || request.query.cwd === "") return reply.code(400).send({ error: "cwd query parameter is required" });
     try {
       if (request.query.mode === "path") return await listPathSuggestions(request.query.cwd, request.query.q ?? "");
-      return await listFileSuggestions(request.query.cwd, request.query.q ?? "", request.query.kind);
+      return await listFileSuggestions(request.query.cwd, request.query.q ?? "", { kind: request.query.kind, scope: request.query.scope });
     } catch (error) {
       return reply.code(400).send({ error: error instanceof Error ? error.message : String(error) });
     }

src/server/workspaces/fileSuggestions.test.ts

@@ -0,0 +1,75 @@
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { listFileSuggestions, type FileSuggestionDependencies } from "./fileSuggestions";
+
+const temporaryRoots: string[] = [];
+
+async function tempWorkspace(): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), "pi-web-files-"));
+  temporaryRoots.push(root);
+  return root;
+}
+
+afterEach(async () => {
+  await Promise.all(temporaryRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("file suggestions", () => {
+  it("uses tracked git files for tracked-scope suggestions", async () => {
+    const calls: { file: string; args: string[] }[] = [];
+    const deps: FileSuggestionDependencies = {
+      execFile: (file, args) => {
+        calls.push({ file, args });
+        if (file === "git" && args.join(" ") === "ls-files") return Promise.resolve({ stdout: "src/app.ts\nREADME.md\n" });
+        return Promise.reject(new Error(`unexpected command: ${file} ${args.join(" ")}`));
+      },
+    };
+
+    await expect(listFileSuggestions("/repo", "", { scope: "tracked" }, deps)).resolves.toEqual([
+      { path: "src/", kind: "tracked" },
+      { path: "README.md", kind: "tracked" },
+      { path: "src/app.ts", kind: "tracked" },
+    ]);
+    expect(calls).toEqual([{ file: "git", args: ["ls-files"] }]);
+  });
+
+  it("asks ripgrep for hidden and ignored files in all-file scope", async () => {
+    const calls: { file: string; args: string[] }[] = [];
+    const deps: FileSuggestionDependencies = {
+      execFile: (file, args) => {
+        calls.push({ file, args });
+        return Promise.resolve({ stdout: "node_modules/pkg/index.js\nsrc/app.ts\n" });
+      },
+    };
+
+    await expect(listFileSuggestions("/repo", "pkg", { scope: "all" }, deps)).resolves.toEqual([
+      { path: "node_modules/pkg/", kind: "other" },
+      { path: "node_modules/pkg/index.js", kind: "other" },
+    ]);
+    expect(calls).toEqual([{ file: "rg", args: ["--files", "--hidden", "--no-ignore"] }]);
+  });
+
+  it("falls back to a bounded filesystem scan without directory exclusions when git and rg are unavailable", async () => {
+    const root = await tempWorkspace();
+    await mkdir(join(root, "src"), { recursive: true });
+    await mkdir(join(root, "node_modules", "pkg"), { recursive: true });
+    await writeFile(join(root, "README.md"), "hello");
+    await writeFile(join(root, "src", "app.ts"), "export {};\n");
+    await writeFile(join(root, "node_modules", "pkg", "index.js"), "module.exports = {};\n");
+
+    const deps: FileSuggestionDependencies = {
+      execFile: (file) => Promise.reject(Object.assign(new Error(`spawn ${file} ENOENT`), { code: "ENOENT" })),
+    };
+
+    await expect(listFileSuggestions(root, "", { scope: "all" }, deps)).resolves.toEqual([
+      { path: "node_modules/", kind: "other" },
+      { path: "node_modules/pkg/", kind: "other" },
+      { path: "src/", kind: "other" },
+      { path: "node_modules/pkg/index.js", kind: "other" },
+      { path: "README.md", kind: "other" },
+      { path: "src/app.ts", kind: "other" },
+    ]);
+  });
+});

src/server/workspaces/fileSuggestions.ts

@@ -5,13 +5,32 @@ import { promisify } from "node:util";
 import type { ClientFileSuggestion } from "../types.js";
 
 const execFileAsync = promisify(execFile);
+const commandMaxBuffer = 1024 * 1024 * 8;
+const maxFilesystemFallbackPaths = 20_000;
 
-export async function listFileSuggestions(cwd: string, query = "", kind?: ClientFileSuggestion["kind"]): Promise<ClientFileSuggestion[]> {
-  const normalizedQuery = query.replace(/^@/, "").toLowerCase();
-  const files = await listGitFiles(cwd).catch(() => listPlainFiles(cwd));
+interface ExecFileOptions {
+  cwd: string;
+  maxBuffer: number;
+}
+
+export type FileSuggestionScope = "tracked" | "all";
+
+export interface FileSuggestionOptions {
+  kind?: ClientFileSuggestion["kind"] | undefined;
+  scope?: FileSuggestionScope | undefined;
+}
+
+export interface FileSuggestionDependencies {
+  execFile?: (file: string, args: string[], options: ExecFileOptions) => Promise<{ stdout: string }>;
+}
+
+export async function listFileSuggestions(cwd: string, query = "", options: FileSuggestionOptions = {}, deps: FileSuggestionDependencies = {}): Promise<ClientFileSuggestion[]> {
+  const normalizedQuery = normalizeFileQuery(query);
+  const exec = deps.execFile ?? execFileAsync;
+  const files = await listFilesForScope(cwd, options.scope, exec);
   return files
-    .filter((file) => !kind || file.kind === kind)
-    .filter((file) => !normalizedQuery || file.path.toLowerCase().includes(normalizedQuery))
+    .filter((file) => options.kind === undefined || file.kind === options.kind)
+    .filter((file) => normalizedQuery === "" || file.path.toLowerCase().includes(normalizedQuery))
     .sort((a, b) => Number(!a.path.endsWith("/")) - Number(!b.path.endsWith("/")) || a.path.localeCompare(b.path))
     .slice(0, 80);
 }
@@ -39,10 +58,20 @@ export async function listPathSuggestions(cwd: string, prefix = ""): Promise<Cli
     .slice(0, 80);
 }
 
-async function listGitFiles(cwd: string): Promise<ClientFileSuggestion[]> {
+async function listFilesForScope(cwd: string, scope: FileSuggestionScope | undefined, exec: NonNullable<FileSuggestionDependencies["execFile"]>): Promise<ClientFileSuggestion[]> {
+  if (scope === "all") return listPlainFiles(cwd, exec, true);
+  if (scope === "tracked") return listTrackedFiles(cwd, exec).catch(() => listPlainFiles(cwd, exec, true));
+  return listGitFiles(cwd, exec).catch(() => listPlainFiles(cwd, exec, false));
+}
+
+async function listTrackedFiles(cwd: string, exec: NonNullable<FileSuggestionDependencies["execFile"]>): Promise<ClientFileSuggestion[]> {
+  return withDirectories(lines(await git(cwd, ["ls-files"], exec)), "tracked");
+}
+
+async function listGitFiles(cwd: string, exec: NonNullable<FileSuggestionDependencies["execFile"]>): Promise<ClientFileSuggestion[]> {
   const [tracked, untracked] = await Promise.all([
-    git(cwd, ["ls-files"]),
-    git(cwd, ["ls-files", "--others", "--exclude-standard"]),
+    git(cwd, ["ls-files"], exec),
+    git(cwd, ["ls-files", "--others", "--exclude-standard"], exec),
   ]);
   return [
     ...withDirectories(lines(tracked), "tracked"),
@@ -50,16 +79,63 @@ async function listGitFiles(cwd: string): Promise<ClientFileSuggestion[]> {
   ];
 }
 
-async function listPlainFiles(cwd: string): Promise<ClientFileSuggestion[]> {
-  const { stdout } = await execFileAsync("rg", ["--files"], { cwd, maxBuffer: 1024 * 1024 * 8 });
-  return withDirectories(lines(stdout), "other");
+async function listPlainFiles(cwd: string, exec: NonNullable<FileSuggestionDependencies["execFile"]>, includeIgnored: boolean): Promise<ClientFileSuggestion[]> {
+  try {
+    const args = includeIgnored ? ["--files", "--hidden", "--no-ignore"] : ["--files"];
+    const { stdout } = await exec("rg", args, { cwd, maxBuffer: commandMaxBuffer });
+    return withDirectories(lines(stdout), "other");
+  } catch {
+    return withDirectories(await filesystemFiles(cwd), "other");
+  }
 }
 
-async function git(cwd: string, args: string[]): Promise<string> {
-  const { stdout } = await execFileAsync("git", args, { cwd, maxBuffer: 1024 * 1024 * 8 });
+async function filesystemFiles(cwd: string): Promise<string[]> {
+  const paths: string[] = [];
+  await collectFilesystemFiles(cwd, "", paths, false);
+  return paths;
+}
+
+async function collectFilesystemFiles(cwd: string, relativeDirectory: string, paths: string[], optionalDirectory: boolean): Promise<void> {
+  if (paths.length >= maxFilesystemFallbackPaths) return;
+  const absoluteDirectory = relativeDirectory === "" ? cwd : join(cwd, relativeDirectory);
+  let entries;
+  try {
+    entries = await readdir(absoluteDirectory, { withFileTypes: true });
+  } catch (error) {
+    if (optionalDirectory) return;
+    throw error;
+  }
+
+  entries.sort((a, b) => Number(!a.isDirectory()) - Number(!b.isDirectory()) || a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (paths.length >= maxFilesystemFallbackPaths) return;
+    const relativePath = relativeDirectory === "" ? entry.name : `${relativeDirectory}/${entry.name}`;
+    if (entry.isDirectory()) {
+      await collectFilesystemFiles(cwd, relativePath, paths, true);
+      continue;
+    }
+    if (entry.isFile() || await isSymlinkedFile(cwd, relativePath, entry.isSymbolicLink())) paths.push(relativePath);
+  }
+}
+
+async function isSymlinkedFile(cwd: string, relativePath: string, symbolicLink: boolean): Promise<boolean> {
+  if (!symbolicLink) return false;
+  try {
+    return (await stat(join(cwd, relativePath))).isFile();
+  } catch {
+    return false;
+  }
+}
+
+async function git(cwd: string, args: string[], exec: NonNullable<FileSuggestionDependencies["execFile"]>): Promise<string> {
+  const { stdout } = await exec("git", args, { cwd, maxBuffer: commandMaxBuffer });
   return stdout;
 }
 
+function normalizeFileQuery(query: string): string {
+  return query.replace(/^!@/, "").replace(/^@\s?/, "").toLowerCase();
+}
+
 function lines(text: string): string[] {
   return text.split("\n").map((line) => line.trim()).filter(Boolean);
 }

src/server/workspaces/fileTreeService.test.ts

@@ -17,7 +17,7 @@ afterEach(async () => {
 });
 
 describe("listWorkspaceTree", () => {
-  it("lists visible entries with directories first, sorted by name", async () => {
+  it("lists entries with directories first, sorted by name", async () => {
     const root = await tempWorkspace();
     await mkdir(join(root, "z-dir"));
     await mkdir(join(root, "a-dir"));
@@ -32,7 +32,9 @@ describe("listWorkspaceTree", () => {
     expect(tree.path).toBe("");
     expect(tree.truncated).toBe(false);
     expect(tree.entries.map((entry) => [entry.name, entry.type])).toEqual([
+      [".git", "directory"],
       ["a-dir", "directory"],
+      ["node_modules", "directory"],
       ["z-dir", "directory"],
       ["a.txt", "file"],
       ["b.txt", "file"],

src/server/workspaces/fileTreeService.ts

@@ -11,11 +11,11 @@ export async function listWorkspaceTree(rootPath: string, path: string | undefin
   if (!stat.isDirectory()) throw new Error("Path is not a directory");
 
   const dirents = await readdir(target, { withFileTypes: true });
-  const visible = dirents.filter((entry) => entry.name !== ".git" && entry.name !== "node_modules").sort((a, b) => {
+  const sorted = dirents.sort((a, b) => {
     if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
     return a.name.localeCompare(b.name);
   });
-  const selected = visible.slice(0, MAX_ENTRIES);
+  const selected = sorted.slice(0, MAX_ENTRIES);
   const entries = await Promise.all(selected.map(async (entry): Promise<FileTreeEntry> => {
     const absolute = join(target, entry.name);
     const childRelative = relativePath === "" ? entry.name : `${relativePath}/${entry.name}`;
@@ -24,5 +24,5 @@ export async function listWorkspaceTree(rootPath: string, path: string | undefin
     return { name: entry.name, path: childRelative, type, size: childStat.size, modifiedAt: childStat.mtime.toISOString() };
   }));
 
-  return { path: relativePath, entries, scannedAt: new Date().toISOString(), truncated: visible.length > selected.length };
+  return { path: relativePath, entries, scannedAt: new Date().toISOString(), truncated: sorted.length > selected.length };
 }