@youtyan/code-viewer 0.1.13 → 0.1.15

package/web-src/server/git.ts

@@ -18,8 +18,40 @@ export type GitTreeEntry = {
   path: string;
   type: 'tree' | 'blob' | 'commit';
   children_omitted?: true;
+  children_omitted_reason?: 'heavy' | 'internal' | 'truncated';
 };
 
+const WORKTREE_RECURSIVE_DEPTH_LIMIT = 32;
+export const WORKTREE_RECURSIVE_ENTRY_LIMIT = 50000;
+export const DEFAULT_WORKTREE_OMIT_DIR_NAMES = [
+  'node_modules',
+  '.venv',
+  'venv',
+  '.next',
+  '.nuxt',
+  '.svelte-kit',
+  '.astro',
+  '.vercel',
+  'dist',
+  'build',
+  'out',
+  'target',
+  '.gradle',
+  '__pycache__',
+  '.pytest_cache',
+  '.tox',
+  '.terraform',
+  '.idea',
+  '.vscode',
+  'vendor',
+  '.cache',
+  'coverage',
+  'DerivedData',
+  'Pods',
+  'bin',
+  'obj',
+];
+
 function run(args: string[], cwd: string): { code: number; stdout: string; stderr: string } {
   const proc = Bun.spawnSync(args, { cwd, stdout: 'pipe', stderr: 'pipe' });
   return {
@@ -156,24 +188,94 @@ function sortTreeEntries(entries: GitTreeEntry[]): GitTreeEntry[] {
   });
 }
 
-function worktreeDirectChildren(cwd: string, path: string): GitTreeEntry[] {
-  const base = normalizeTreePath(path);
-  const dir = join(cwd, base);
-  try {
-    return sortTreeEntries(readdirSync(dir, { withFileTypes: true }).map((entry) => {
-      const entryPath = base ? `${base}/${entry.name}` : entry.name;
-      const type = entry.isDirectory()
-        ? hasDotGitEntry(join(dir, entry.name)) ? 'commit' as const : 'tree' as const
-        : 'blob' as const;
-      return {
-        name: entry.name,
+function omittedWorktreeDirectoryReason(name: string, omitDirNames: Set<string>): GitTreeEntry['children_omitted_reason'] | undefined {
+  if (name === '.git') return 'internal';
+  return omitDirNames.has(name) ? 'heavy' : undefined;
+}
+
+function worktreeEntryFromDirent(base: string, dir: string, name: string, isDirectory: boolean, omitDirNames: Set<string>): GitTreeEntry {
+  const entryPath = base ? `${base}/${name}` : name;
+  const type = isDirectory
+    ? hasDotGitEntry(join(dir, name)) ? 'commit' as const : 'tree' as const
+    : 'blob' as const;
+  const omittedReason = type === 'tree' ? omittedWorktreeDirectoryReason(name, omitDirNames) : undefined;
+  return omittedReason
+    ? {
+        name,
         path: entryPath,
         type,
-      };
-    }));
+        children_omitted: true,
+        children_omitted_reason: omittedReason,
+      }
+    : { name, path: entryPath, type };
+}
+
+function worktreeFilesystemEntries(cwd: string, path: string, recursive: boolean, omitDirNames: string[] = DEFAULT_WORKTREE_OMIT_DIR_NAMES): GitTreeEntry[] {
+  const base = normalizeTreePath(path);
+  const root = join(cwd, base);
+  const omitDirNameSet = new Set(omitDirNames);
+  let directEntries: GitTreeEntry[];
+  try {
+    const dirents = readdirSync(root, { withFileTypes: true });
+    directEntries = sortTreeEntries(dirents
+      .map(entry => worktreeEntryFromDirent(base, root, entry.name, entry.isDirectory(), omitDirNameSet)));
   } catch {
     return [];
   }
+  if (!recursive) return directEntries;
+
+  const fileEntries: GitTreeEntry[] = [];
+  let truncated = false;
+  const pushRecursiveEntry = (entry: GitTreeEntry): boolean => {
+    if (fileEntries.length >= WORKTREE_RECURSIVE_ENTRY_LIMIT) {
+      if (!truncated) {
+        fileEntries.push({
+          name: 'more...',
+          path: '__code_viewer_truncated__',
+          type: 'tree',
+          children_omitted: true,
+          children_omitted_reason: 'truncated',
+        });
+        truncated = true;
+      }
+      return false;
+    }
+    fileEntries.push(entry);
+    return true;
+  };
+  const walk = (dir: string, prefix: string, depth: number) => {
+    if (truncated) return;
+    if (depth >= WORKTREE_RECURSIVE_DEPTH_LIMIT) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const entryPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const omittedReason = omittedWorktreeDirectoryReason(entry.name, omitDirNameSet);
+        if (omittedReason) {
+          if (!pushRecursiveEntry({
+            name: entry.name,
+            path: entryPath,
+            type: 'tree',
+            children_omitted: true,
+            children_omitted_reason: omittedReason,
+          })) return;
+          continue;
+        }
+        if (hasDotGitEntry(full)) continue;
+        walk(full, entryPath, depth + 1);
+      } else if (entry.isFile() || entry.isSymbolicLink()) {
+        if (!pushRecursiveEntry({ name: entry.name, path: entryPath, type: 'blob' })) return;
+      }
+    }
+  };
+  walk(root, base, 0);
+  return combineDirectAndRecursiveFiles(directEntries, fileEntries.sort((a, b) => a.path.localeCompare(b.path)));
 }
 
 function hasDotGitEntry(dir: string): boolean {
@@ -185,20 +287,6 @@ function hasDotGitEntry(dir: string): boolean {
   }
 }
 
-function worktreeRecursiveFiles(cwd: string, path: string): GitTreeEntry[] {
-  const base = normalizeTreePath(path);
-  const trackedArgs = ['git', '-c', 'core.quotepath=false', 'ls-files', '-z'];
-  if (base) trackedArgs.push('--', `${base}/`);
-  const tracked = run(trackedArgs, cwd);
-  const paths = tracked.code === 0 ? tracked.stdout.split('\0').filter(Boolean) : [];
-  paths.push(...untracked(cwd, base));
-  return [...new Set(paths)].filter(Boolean).sort().map((entryPath) => ({
-    name: entryPath.split('/').pop() || entryPath,
-    path: entryPath,
-    type: 'blob' as const,
-  }));
-}
-
 function gitTreeEntries(ref: string, path: string, cwd: string, recursive: boolean): { code: number; entries: GitTreeEntry[]; stderr: string } {
   const base = normalizeTreePath(path);
   const args = ['git', '-c', 'core.quotepath=false', 'ls-tree'];
@@ -227,31 +315,6 @@ function combineDirectAndRecursiveFiles(directEntries: GitTreeEntry[], fileEntri
   ];
 }
 
-function ignoredWorktreePaths(cwd: string, path: string): Set<string> {
-  const base = normalizeTreePath(path);
-  const args = ['git', '-c', 'core.quotepath=false', 'status', '--ignored', '--porcelain=v1', '-z', '--'];
-  if (base) args.push(`${base}/`);
-  const res = run(args, cwd);
-  const ignored = new Set<string>();
-  if (res.code !== 0) return ignored;
-  const records = res.stdout.split('\0').filter(Boolean);
-  for (let i = 0; i < records.length; i++) {
-    const rec = records[i];
-    if (!rec.startsWith('!! ')) continue;
-    const path = rec.slice(3).replace(/\/+$/g, '');
-    if (path) ignored.add(path);
-  }
-  return ignored;
-}
-
-function annotateOmittedWorktreeChildren(entries: GitTreeEntry[], ignoredPaths: Set<string>): GitTreeEntry[] {
-  return entries.map((entry) => {
-    return entry.type === 'tree' && ignoredPaths.has(entry.path)
-      ? { ...entry, children_omitted: true }
-      : entry;
-  });
-}
-
 export function worktreeEntries(cwd: string, path: string): GitTreeEntry[] {
   return listTree('worktree', path, cwd).entries;
 }
@@ -272,16 +335,11 @@ export function listTree(
   ref: string,
   path: string,
   cwd: string,
-  options: { recursive?: boolean } = {},
+  options: { recursive?: boolean; omitDirNames?: string[] } = {},
 ): { code: number; entries: GitTreeEntry[]; stderr: string } {
   const base = normalizeTreePath(path);
   if (ref === 'worktree') {
-    const directEntries = worktreeDirectChildren(cwd, base);
-    const ignoredPaths = ignoredWorktreePaths(cwd, base);
-    const annotatedDirectEntries = annotateOmittedWorktreeChildren(directEntries, ignoredPaths);
-    if (!options.recursive) return { code: 0, entries: annotatedDirectEntries, stderr: '' };
-    const recursiveEntries = worktreeRecursiveFiles(cwd, base);
-    return { code: 0, entries: combineDirectAndRecursiveFiles(annotatedDirectEntries, recursiveEntries), stderr: '' };
+    return { code: 0, entries: worktreeFilesystemEntries(cwd, base, !!options.recursive, options.omitDirNames), stderr: '' };
   }
 
   const direct = gitTreeEntries(ref, base, cwd, false);

package/web-src/server/preview.ts

@@ -3,7 +3,7 @@
 import { closeSync, constants, existsSync, lstatSync, openSync, readFileSync, realpathSync, statSync, unlinkSync, watch, writeFileSync } from 'node:fs';
 import { basename, dirname, extname, join, normalize, relative } from 'node:path';
 import { APP_ENTRY_PATHS, SPA_PATHS } from '../routes';
-import type { DiffMeta, FileDiffResponse, FileMeta, FileRangeResponse, FileSearchListResponse, GrepMatch, GrepResponse, RepoTreeResponse } from '../types';
+import type { DiffMeta, FileDiffResponse, FileMeta, FileRangeResponse, FileSearchListResponse, GrepMatch, GrepResponse, RepoTreeResponse, SettingsResponse } from '../types';
 import { cacheFresh, fileDiffCacheKey, setTimedCacheEntry, type TimedCacheEntry } from './cache';
 import { startDevAssetReload } from './dev-assets';
 import * as git from './git';
@@ -45,6 +45,8 @@ let cliArgs = DEFAULT_ARGS;
 let listenPort = 0;
 let allowUpload = false;
 let uploadAllowedByCli = false;
+let scopeOmitDirNames = git.DEFAULT_WORKTREE_OMIT_DIR_NAMES;
+let scopeOmitDirCliOverride: string[] | null = null;
 let rgAvailableCache: boolean | null = null;
 
 const enc = new TextEncoder();
@@ -79,7 +81,12 @@ Examples:
         console.error('--cwd requires a value');
         process.exit(1);
       }
-      cwd = git.repoRoot(next) || cwd;
+      try {
+        cwd = git.repoRoot(next) || realpathSync(next);
+      } catch {
+        console.error('--cwd must point to an existing directory');
+        process.exit(1);
+      }
     } else if (arg === '--port') {
       const next = process.argv[++i];
       const parsed = Number(next);
@@ -93,12 +100,25 @@ Examples:
     } else if (arg === '--allow-upload') {
       allowUpload = true;
       uploadAllowedByCli = true;
+    } else if (arg === '--scope-omit-dir') {
+      const next = process.argv[++i];
+      if (!next) {
+        console.error('--scope-omit-dir requires a directory name');
+        process.exit(1);
+      }
+      scopeOmitDirCliOverride = normalizeScopeOmitDirNames([...(scopeOmitDirCliOverride || []), next]);
     } else {
       rest.push(arg);
     }
   }
   if (rest.length) cliArgs = rest;
   if (!uploadAllowedByCli) allowUpload = loadProjectConfigUploadEnabled();
+  const configScopeOmitDirs = loadProjectConfigScopeOmitDirs();
+  if (scopeOmitDirCliOverride) {
+    scopeOmitDirNames = scopeOmitDirCliOverride;
+  } else if (configScopeOmitDirs) {
+    scopeOmitDirNames = configScopeOmitDirs;
+  }
 }
 
 function json(data: unknown, init: ResponseInit = {}) {
@@ -180,6 +200,7 @@ function guessMediaKind(path: string) {
   const ext = extname(path).slice(1).toLowerCase();
   if (['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'avif', 'bmp', 'ico'].includes(ext)) return 'image';
   if (['mp4', 'webm', 'mov'].includes(ext)) return 'video';
+  if (['mp3', 'wav', 'ogg', 'flac', 'm4a', 'aac', 'opus'].includes(ext)) return 'audio';
   return null;
 }
 
@@ -305,29 +326,68 @@ function safeRepoPath(path: string) {
   return path === '' || safePath(path);
 }
 
-function loadProjectConfigUploadEnabled(): boolean {
+function normalizeScopeOmitDirNames(names: unknown): string[] {
+  if (!Array.isArray(names)) return [];
+  return [...new Set(names
+    .filter((name): name is string => typeof name === 'string')
+    .map(name => name.trim())
+    .filter(name => name && name.length <= 64 && !name.includes('/') && !name.includes('\\') && !name.includes('\0') && name !== '.' && name !== '..' && name !== '.git'))]
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function parseScopeOmitDirNamesQuery(value: string): string[] | null {
+  const names = value ? value.split(',') : [];
+  if (names.length > 100) return null;
+  for (const raw of names) {
+    const name = raw.trim();
+    if (!name || name.length > 64 || name.includes('/') || name.includes('\\') || name.includes('\0') || name === '.' || name === '..' || name === '.git') return null;
+  }
+  return normalizeScopeOmitDirNames(names);
+}
+
+function loadProjectConfig(): Record<string, unknown> | null {
   const full = join(cwd, '.code-viewer.json');
-  if (!existsSync(full)) return false;
+  if (!existsSync(full)) return null;
   let realCwd: string;
   let realConfig: string;
   try {
     realCwd = realpathSync(cwd);
     realConfig = realpathSync(full);
   } catch {
-    return false;
+    return null;
   }
-  if (dirname(realConfig) !== realCwd || basename(realConfig) !== '.code-viewer.json') return false;
+  if (dirname(realConfig) !== realCwd || basename(realConfig) !== '.code-viewer.json') return null;
   try {
-    const config = JSON.parse(readFileSync(realConfig, 'utf8')) as {
-      upload?: { enabled?: unknown };
-    };
-    if (!config.upload) return false;
-    return config.upload.enabled === true;
+    const parsed = JSON.parse(readFileSync(realConfig, 'utf8'));
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed) && 'version' in parsed && (parsed as { version?: unknown }).version !== 1) return null;
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed as Record<string, unknown>
+      : null;
   } catch {
-    return false;
+    return null;
   }
 }
 
+function loadProjectConfigUploadEnabled(): boolean {
+  const config = loadProjectConfig() as { upload?: { enabled?: unknown } } | null;
+  return config?.upload?.enabled === true;
+}
+
+function loadProjectConfigScopeOmitDirs(): string[] | null {
+  const config = loadProjectConfig() as { scope?: { omitDirs?: unknown } } | null;
+  if (!config?.scope || !Array.isArray(config.scope.omitDirs)) return null;
+  return normalizeScopeOmitDirNames(config.scope.omitDirs);
+}
+
+function scopeOmitDirNamesFromQuery(url: URL): string[] {
+  if (!url.searchParams.has('omit_dirs')) return scopeOmitDirNames;
+  return parseScopeOmitDirNamesQuery(url.searchParams.get('omit_dirs') || '') || scopeOmitDirNames;
+}
+
+function invalidScopeOmitDirNamesQuery(url: URL): boolean {
+  return url.searchParams.has('omit_dirs') && !parseScopeOmitDirNamesQuery(url.searchParams.get('omit_dirs') || '');
+}
+
 function isGitInternalPath(path: string): boolean {
   return path.split(/[\\/]+/).some(part => part.toLowerCase() === '.git');
 }
@@ -395,7 +455,8 @@ function handleTree(url: URL) {
   if ((target === 'worktree' || target === '') && isGitInternalPath(path)) return text('forbidden', 403);
   if (target !== 'worktree' && !git.verifyTreeRef(target, cwd)) return text('invalid target', 400);
   const recursive = url.searchParams.get('recursive') === '1';
-  const entries = git.listTree(target, path, cwd, { recursive }).entries;
+  if (invalidScopeOmitDirNamesQuery(url)) return text('invalid omit dirs', 400);
+  const entries = git.listTree(target, path, cwd, { recursive, omitDirNames: scopeOmitDirNamesFromQuery(url) }).entries;
   return json({
     ref: target,
     path,
@@ -407,20 +468,34 @@ function handleTree(url: URL) {
   } satisfies RepoTreeResponse);
 }
 
+function handleSettings() {
+  return json({
+    project: basename(cwd),
+    scope: {
+      omit_dirs_effective: scopeOmitDirNames,
+      omit_dirs_built_in: git.DEFAULT_WORKTREE_OMIT_DIR_NAMES,
+      max_entries: git.WORKTREE_RECURSIVE_ENTRY_LIMIT,
+    },
+  } satisfies SettingsResponse);
+}
+
 function handleFiles(url: URL) {
   const target = url.searchParams.get('ref') || url.searchParams.get('target') || 'worktree';
   if (target !== 'worktree' && !git.verifyTreeRef(target, cwd)) return text('invalid target', 400);
-  const key = target || 'worktree';
+  if (invalidScopeOmitDirNamesQuery(url)) return text('invalid omit dirs', 400);
+  const omitDirNames = scopeOmitDirNamesFromQuery(url);
+  const key = `${target || 'worktree'}\0${omitDirNames.join('\0')}`;
   const cached = fileListCache.get(key);
   if (cached && cached.generation === generation) return json(cached.body);
-  const entries = git.listTree(key, '', cwd, { recursive: true }).entries;
-  const body = buildFileSearchList(key, generation, entries);
+  const ref = target || 'worktree';
+  const entries = git.listTree(ref, '', cwd, { recursive: true, omitDirNames }).entries;
+  const body = buildFileSearchList(ref, generation, entries);
   fileListCache.set(key, { generation, body });
   return json(body);
 }
 
-function parseGrepPaths(url: URL): string[] {
-  return url.searchParams.getAll('path').filter(path => safePath(path) && !isGitInternalPath(path));
+function parseGrepPaths(url: URL, omitDirNames: string[]): string[] {
+  return url.searchParams.getAll('path').filter(path => safePath(path) && !isGitInternalPath(path) && !isSkippableSearchPath(path, omitDirNames));
 }
 
 function rgAvailable(): boolean {
@@ -430,12 +505,12 @@ function rgAvailable(): boolean {
   return rgAvailableCache;
 }
 
-function grepWorktreeFallback(query: string, max: number, paths: string[]): GrepMatch[] {
+function grepWorktreeFallback(query: string, max: number, paths: string[], omitDirNames: string[]): GrepMatch[] {
   const candidates = paths.length ? paths : git.worktreeFiles(cwd).map(entry => entry.path);
   const matches: GrepMatch[] = [];
   for (const path of candidates) {
     if (matches.length >= max) break;
-    if (!safePath(path) || isGitInternalPath(path) || isSkippableSearchPath(path)) continue;
+    if (!safePath(path) || isGitInternalPath(path) || isSkippableSearchPath(path, omitDirNames)) continue;
     const full = safeWorktreePath(path);
     if (!full) continue;
     let stat;
@@ -457,23 +532,23 @@ function grepWorktreeFallback(query: string, max: number, paths: string[]): Grep
   return matches;
 }
 
-function grepWorktree(query: string, max: number, paths: string[], regex: boolean): GrepResponse {
+function grepWorktree(query: string, max: number, paths: string[], regex: boolean, omitDirNames: string[]): GrepResponse {
   if (rgAvailable()) {
-    const safePaths = paths.filter(path => safePath(path) && !isGitInternalPath(path) && safeWorktreePath(path));
-    const args = buildRgArgs(query, max, safePaths, regex);
+    const safePaths = paths.filter(path => safePath(path) && !isGitInternalPath(path) && !isSkippableSearchPath(path, omitDirNames) && safeWorktreePath(path));
+    const args = buildRgArgs(query, max, safePaths, regex, omitDirNames);
     const proc = Bun.spawnSync(args, { cwd, stdout: 'pipe', stderr: 'pipe', stdin: 'ignore', timeout: 5000, killSignal: 'SIGKILL' });
     const stdout = new TextDecoder().decode(proc.stdout);
-    const matches = parseRgOutput(stdout, max)
-      .filter(match => safePath(match.path) && !isGitInternalPath(match.path) && !!safeWorktreePath(match.path));
+    const matches = parseRgOutput(stdout, max, omitDirNames)
+      .filter(match => safePath(match.path) && !isGitInternalPath(match.path) && !isSkippableSearchPath(match.path, omitDirNames) && !!safeWorktreePath(match.path));
     return { ref: 'worktree', engine: 'rg', truncated: matches.length >= max, matches };
   }
   if (regex) return { ref: 'worktree', engine: 'fallback', truncated: false, matches: [] };
-  const matches = grepWorktreeFallback(query, max, paths);
+  const matches = grepWorktreeFallback(query, max, paths, omitDirNames);
   return { ref: 'worktree', engine: 'fallback', truncated: matches.length >= max, matches };
 }
 
-function grepTreeRef(ref: string, query: string, max: number, paths: string[], regex: boolean): GrepResponse {
-  const safePaths = paths.filter(path => safePath(path) && !isGitInternalPath(path));
+function grepTreeRef(ref: string, query: string, max: number, paths: string[], regex: boolean, omitDirNames: string[]): GrepResponse {
+  const safePaths = paths.filter(path => safePath(path) && !isGitInternalPath(path) && !isSkippableSearchPath(path, omitDirNames));
   const args = [
     'git', '-c', 'core.quotepath=false', 'grep',
     '-n', '--column', '-i', regex ? '-E' : '-F', '--no-color',
@@ -483,7 +558,7 @@ function grepTreeRef(ref: string, query: string, max: number, paths: string[], r
   ];
   const proc = Bun.spawnSync(args, { cwd, stdout: 'pipe', stderr: 'pipe', stdin: 'ignore', timeout: 5000, killSignal: 'SIGKILL' });
   const stdout = new TextDecoder().decode(proc.stdout);
-  const matches = parseGitGrepOutput(stdout, ref, max).slice(0, max);
+  const matches = parseGitGrepOutput(stdout, ref, max, omitDirNames).slice(0, max);
   return { ref, engine: 'git', truncated: matches.length >= max, matches };
 }
 
@@ -491,12 +566,14 @@ function handleGrep(url: URL) {
   const query = url.searchParams.get('q') || '';
   const ref = url.searchParams.get('ref') || 'worktree';
   const max = normalizeGrepMax(url.searchParams.get('max'));
-  const paths = parseGrepPaths(url);
+  if (invalidScopeOmitDirNamesQuery(url)) return text('invalid omit dirs', 400);
+  const omitDirNames = scopeOmitDirNamesFromQuery(url);
+  const paths = parseGrepPaths(url, omitDirNames);
   const regex = url.searchParams.get('regex') === '1';
   if (!query.trim()) return json({ ref, engine: ref === 'worktree' ? 'fallback' : 'git', truncated: false, matches: [] } satisfies GrepResponse);
-  if (ref === 'worktree' || ref === '') return json(grepWorktree(query, max, paths, regex));
+  if (ref === 'worktree' || ref === '') return json(grepWorktree(query, max, paths, regex, omitDirNames));
   if (!git.verifyTreeRef(ref, cwd)) return text('invalid target', 400);
-  return json(grepTreeRef(ref, query, max, paths, regex));
+  return json(grepTreeRef(ref, query, max, paths, regex, omitDirNames));
 }
 
 function handleFileDiff(url: URL) {
@@ -641,7 +718,9 @@ function rawFileHeaders(path: string, size: number | null = null): HeadersInit {
   const mime: Record<string, string> = {
     '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
     '.webp': 'image/webp', '.svg': 'image/svg+xml', '.mp4': 'video/mp4', '.webm': 'video/webm',
-    '.pdf': 'application/pdf',
+    '.mov': 'video/quicktime', '.pdf': 'application/pdf',
+    '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.ogg': 'audio/ogg', '.flac': 'audio/flac',
+    '.m4a': 'audio/mp4', '.aac': 'audio/aac', '.opus': 'audio/ogg',
   };
   const headers: Record<string, string> = {
     'Content-Type': mime[extname(path).toLowerCase()] || 'application/octet-stream',
@@ -842,6 +921,7 @@ const server = Bun.serve({
     const staticResponse = staticFile(url.pathname);
     if (staticResponse) return staticResponse;
     if (url.pathname === '/diff.json') return handleDiffJson(url);
+    if (url.pathname === '/_settings') return handleSettings();
     if (url.pathname === '/_tree') return handleTree(url);
     if (url.pathname === '/_files') return handleFiles(url);
     if (url.pathname === '/_grep') return handleGrep(url);

package/web-src/server/search.ts

@@ -12,10 +12,11 @@ export function normalizeGrepMax(value: string | null): number {
   return Math.min(parsed, GREP_ABSOLUTE_MAX);
 }
 
-export function isSkippableSearchPath(path: string): boolean {
+export function isSkippableSearchPath(path: string, omitDirNames: string[] = []): boolean {
+  const omitDirs = new Set(omitDirNames.map(name => name.toLowerCase()));
   return path.split(/[\\/]+/).some(part => {
     const lower = part.toLowerCase();
-    return lower === '.git' || lower === 'node_modules';
+    return lower === '.git' || omitDirs.has(lower);
   });
 }
 
@@ -51,8 +52,9 @@ export function buildFileSearchList(ref: string, generation: number, entries: Gi
   };
 }
 
-export function buildRgArgs(query: string, max: number, paths: string[], regex = false): string[] {
+export function buildRgArgs(query: string, max: number, paths: string[], regex = false, omitDirNames: string[] = []): string[] {
   const safePaths = paths.length ? paths : ['.'];
+  const omitGlobs = omitDirNames.flatMap(name => ['--glob', `!${name}/**`, '--glob', `!**/${name}/**`]);
   const args = [
     'rg',
     '--no-config',
@@ -66,6 +68,7 @@ export function buildRgArgs(query: string, max: number, paths: string[], regex =
     String(max),
     '--max-filesize',
     '2M',
+    ...omitGlobs,
     '-e',
     query,
     '--',
@@ -75,7 +78,7 @@ export function buildRgArgs(query: string, max: number, paths: string[], regex =
   return args;
 }
 
-export function parseRgOutput(stdout: string, max: number): GrepMatch[] {
+export function parseRgOutput(stdout: string, max: number, omitDirNames: string[] = []): GrepMatch[] {
   const matches: GrepMatch[] = [];
   for (const line of stdout.split('\n')) {
     if (!line || matches.length >= max) continue;
@@ -85,17 +88,17 @@ export function parseRgOutput(stdout: string, max: number): GrepMatch[] {
     const lineNo = Number(parsed[2]);
     const column = Number(parsed[3]);
     const preview = parsed[4];
-    if (!path || !lineNo || !column || isSkippableSearchPath(path)) continue;
+    if (!path || !lineNo || !column || isSkippableSearchPath(path, omitDirNames)) continue;
     matches.push({ path, line: lineNo, column, preview: preview.slice(0, 500) });
   }
   return matches;
 }
 
-export function parseGitGrepOutput(stdout: string, ref: string, max: number): GrepMatch[] {
+export function parseGitGrepOutput(stdout: string, ref: string, max: number, omitDirNames: string[] = []): GrepMatch[] {
   const prefix = ref + ':';
   const normalized = stdout
     .split('\n')
     .map(line => line.startsWith(prefix) ? line.slice(prefix.length) : line)
     .join('\n');
-  return parseRgOutput(normalized, max);
+  return parseRgOutput(normalized, max, omitDirNames);
 }

package/web-src/types.ts

@@ -38,6 +38,7 @@ export type RepoTreeEntry = {
   path: string;
   type: 'tree' | 'blob' | 'commit';
   children_omitted?: true;
+  children_omitted_reason?: 'heavy' | 'internal' | 'truncated';
 };
 
 export type RepoTreeResponse = {
@@ -53,6 +54,15 @@ export type RepoTreeResponse = {
   } | null;
 };
 
+export type SettingsResponse = {
+  project: string;
+  scope: {
+    omit_dirs_effective: string[];
+    omit_dirs_built_in: string[];
+    max_entries: number;
+  };
+};
+
 export type FileSearchListResponse = {
   ref: string;
   generation: number;