Implement exclude patterns from workspace settings

Author: thenamankumar

.sourcegraph/.ignore

@@ -0,0 +1 @@
+recordings/

lib/shared/package.json

@@ -35,6 +35,7 @@
     "lexical": "^0.17.0",
     "lodash": "^4.17.21",
     "lru-cache": "^10.0.0",
+    "minimatch": "^9.0.3",
     "ollama": "^0.5.1",
     "re2js": "^0.4.1",
     "semver": "^7.5.4",

lib/shared/src/cody-ignore/context-filters-provider.ts

@@ -1,6 +1,7 @@
 import { isError } from 'lodash'
 import isEqual from 'lodash/isEqual'
 import { LRUCache } from 'lru-cache'
+import { minimatch } from 'minimatch'
 import type { Observable } from 'observable-fns'
 import { RE2JS as RE2 } from 're2js'
 import type * as vscode from 'vscode'
@@ -22,6 +23,8 @@ import {
 import { wrapInActiveSpan } from '../tracing'
 import { createSubscriber } from '../utils'
 
+type GetExcludePattern = (workspaceFolder: vscode.WorkspaceFolder | null) => Promise<string>
+
 interface ParsedContextFilters {
     include: null | ParsedContextFilterItem[]
     exclude: null | ParsedContextFilterItem[]
@@ -32,13 +35,21 @@ interface ParsedContextFilterItem {
     filePathPatterns?: RE2[]
 }
 
+enum ContextFiltersProviderError {
+    NoRepoFound = 'no-repo-found',
+    NonFileUri = 'non-file-uri',
+    HasIgnoreEverythingFilters = 'has-ignore-everything-filters',
+    ExcludePatternMatch = 'exclude-pattern-match',
+}
+
 // Note: This can not be an empty string to make all non `false` values truthy.
 export type IsIgnored =
     | false
     | Error
-    | 'has-ignore-everything-filters'
-    | 'non-file-uri'
-    | 'no-repo-found'
+    | ContextFiltersProviderError.NoRepoFound
+    | ContextFiltersProviderError.NonFileUri
+    | ContextFiltersProviderError.HasIgnoreEverythingFilters
+    | ContextFiltersProviderError.ExcludePatternMatch
     | `repo:${string}`
 
 export type GetRepoNamesContainingUri = (
@@ -92,6 +103,11 @@ export class ContextFiltersProvider implements vscode.Disposable {
     private readonly contextFiltersSubscriber = createSubscriber<ContextFilters | Error>()
     public readonly onContextFiltersChanged = this.contextFiltersSubscriber.subscribe
 
+    static excludePatternGetter: {
+        getExcludePattern: GetExcludePattern
+        getWorkspaceFolder: (uri: vscode.Uri) => vscode.WorkspaceFolder | null
+    }
+
     // Fetches context filters and updates the cached filter results
     private async fetchContextFilters(): Promise<RefetchIntervalHint> {
         try {
@@ -223,12 +239,19 @@ export class ContextFiltersProvider implements vscode.Disposable {
 
         await this.fetchIfNeeded()
 
+        // Check VS Code exclude patterns
+        if (ContextFiltersProvider.excludePatternGetter) {
+            if (await this.isExcludedByPatterns(uri)) {
+                return ContextFiltersProviderError.ExcludePatternMatch
+            }
+        }
+
         if (this.hasAllowEverythingFilters()) {
             return false
         }
 
         if (this.hasIgnoreEverythingFilters()) {
-            return 'has-ignore-everything-filters'
+            return ContextFiltersProviderError.HasIgnoreEverythingFilters
         }
 
         const maybeError = this.lastContextFiltersResponse
@@ -239,7 +262,7 @@ export class ContextFiltersProvider implements vscode.Disposable {
         // TODO: process non-file URIs https://github.com/sourcegraph/cody/issues/3893
         if (!isFileURI(uri)) {
             logDebug('ContextFiltersProvider', 'isUriIgnored', `non-file URI ${uri.scheme}`)
-            return 'non-file-uri'
+            return ContextFiltersProviderError.NonFileUri
         }
 
         if (!ContextFiltersProvider.repoNameResolver) {
@@ -254,7 +277,7 @@ export class ContextFiltersProvider implements vscode.Disposable {
         )
 
         if (!repoNames?.length) {
-            return 'no-repo-found'
+            return ContextFiltersProviderError.NoRepoFound
         }
 
         const ignoredRepo = repoNames.find(repoName => this.isRepoNameIgnored__noFetch(repoName))
@@ -265,6 +288,34 @@ export class ContextFiltersProvider implements vscode.Disposable {
         return false
     }
 
+    private async isExcludedByPatterns(uri: vscode.Uri): Promise<boolean> {
+        try {
+            const workspaceFolder = ContextFiltersProvider.excludePatternGetter.getWorkspaceFolder(uri)
+            const excludePatternString =
+                await ContextFiltersProvider.excludePatternGetter.getExcludePattern(workspaceFolder)
+
+            // Parse the pattern string {pattern1,pattern2,...} into individual patterns
+            const patterns = this.parseExcludePatternString(excludePatternString)
+
+            // Get the relative path from workspace folder
+            const relativePath = workspaceFolder
+                ? uri.fsPath.substring(workspaceFolder.uri.fsPath.length + 1)
+                : uri.fsPath
+
+            // Check if any pattern matches the file path
+            return patterns.some(pattern => minimatch(relativePath, pattern, { dot: true }))
+        } catch (error) {
+            logDebug('ContextFiltersProvider', 'isExcludedByPatterns error', { error })
+            return false
+        }
+    }
+
+    private parseExcludePatternString(patternString: string): string[] {
+        // Remove the surrounding braces and split by comma
+        const content = patternString.slice(1, -1)
+        return content ? content.split(',') : []
+    }
+
     private reset(): void {
         this.lastFetchTimestamp = 0
         this.lastResultLifetime = Promise.resolve(TRANSIENT_REFETCH_INTERVAL_HINT)

pnpm-lock.yaml

@@ -1,7 +1,161 @@
-import { type IsIgnored, contextFiltersProvider } from '@sourcegraph/cody-shared'
-import type * as vscode from 'vscode'
+import { ContextFiltersProvider, type IsIgnored, contextFiltersProvider } from '@sourcegraph/cody-shared'
+import * as vscode from 'vscode'
 import { type CodyIgnoreFeature, showCodyIgnoreNotification } from './notification'
 
+type IgnoreRecord = Record<string, boolean>
+
+interface CachedExcludeData {
+    gitignoreExclude: IgnoreRecord
+    ignoreExclude: IgnoreRecord
+    sgignoreExclude: IgnoreRecord
+}
+
+const excludeCache = new Map<string, CachedExcludeData>()
+const fileWatchers = new Map<string, vscode.FileSystemWatcher>()
+
+function getCacheKey(workspaceFolder: vscode.WorkspaceFolder | null): string {
+    return workspaceFolder?.uri.toString() ?? 'no-workspace'
+}
+
+export async function initializeCache(workspaceFolder: vscode.WorkspaceFolder | null): Promise<void> {
+    const cacheKey = getCacheKey(workspaceFolder)
+    if (excludeCache.has(cacheKey)) {
+        return
+    }
+
+    const useIgnoreFiles = vscode.workspace
+        .getConfiguration('', workspaceFolder)
+        .get<boolean>('search.useIgnoreFiles')
+
+    let gitignoreExclude: IgnoreRecord = {}
+    let ignoreExclude: IgnoreRecord = {}
+    let sgignoreExclude: IgnoreRecord = {}
+
+    if (useIgnoreFiles && workspaceFolder) {
+        gitignoreExclude = await readIgnoreFile(vscode.Uri.joinPath(workspaceFolder.uri, '.gitignore'))
+        ignoreExclude = await readIgnoreFile(vscode.Uri.joinPath(workspaceFolder.uri, '.ignore'))
+        sgignoreExclude = await readIgnoreFile(
+            vscode.Uri.joinPath(workspaceFolder.uri, '.sourcegraph', '.ignore')
+        )
+
+        setupFileWatcher(workspaceFolder, '.gitignore')
+        setupFileWatcher(workspaceFolder, '.ignore')
+        setupFileWatcher(workspaceFolder, '.sourcegraph/.ignore')
+    }
+
+    excludeCache.set(cacheKey, { gitignoreExclude, ignoreExclude, sgignoreExclude })
+}
+
+function setupFileWatcher(workspaceFolder: vscode.WorkspaceFolder, filename: string): void {
+    const watcherKey = `${workspaceFolder.uri.toString()}:${filename}`
+    if (fileWatchers.has(watcherKey)) {
+        return
+    }
+
+    const pattern = new vscode.RelativePattern(workspaceFolder, filename)
+    const watcher = vscode.workspace.createFileSystemWatcher(pattern)
+
+    const updateCache = async () => {
+        const cacheKey = getCacheKey(workspaceFolder)
+        const cached = excludeCache.get(cacheKey)
+        if (!cached) return
+
+        const fileUri = vscode.Uri.joinPath(workspaceFolder.uri, filename)
+        const ignoreData = await readIgnoreFile(fileUri)
+
+        if (filename === '.gitignore') {
+            cached.gitignoreExclude = ignoreData
+        } else if (filename === '.ignore') {
+            cached.ignoreExclude = ignoreData
+        } else if (filename === '.sourcegraph/.ignore') {
+            cached.sgignoreExclude = ignoreData
+        }
+    }
+
+    watcher.onDidChange(updateCache)
+    watcher.onDidCreate(updateCache)
+    watcher.onDidDelete(() => {
+        const cacheKey = getCacheKey(workspaceFolder)
+        const cached = excludeCache.get(cacheKey)
+        if (!cached) return
+
+        if (filename === '.gitignore') {
+            cached.gitignoreExclude = {}
+        } else if (filename === '.ignore') {
+            cached.ignoreExclude = {}
+        } else if (filename === '.sourcegraph/.ignore') {
+            cached.sgignoreExclude = {}
+        }
+    })
+
+    fileWatchers.set(watcherKey, watcher)
+}
+
+export async function getExcludePattern(
+    workspaceFolder: vscode.WorkspaceFolder | null
+): Promise<string> {
+    await initializeCache(workspaceFolder)
+
+    const config = vscode.workspace.getConfiguration('', workspaceFolder)
+    const filesExclude = config.get<IgnoreRecord>('files.exclude', {})
+    const searchExclude = config.get<IgnoreRecord>('search.exclude', {})
+
+    const cacheKey = getCacheKey(workspaceFolder)
+    const cached = excludeCache.get(cacheKey)
+    const gitignoreExclude = cached?.gitignoreExclude ?? {}
+    const ignoreExclude = cached?.ignoreExclude ?? {}
+    const sgignoreExclude = cached?.sgignoreExclude ?? {}
+
+    const mergedExclude: IgnoreRecord = {
+        ...filesExclude,
+        ...searchExclude,
+        ...gitignoreExclude,
+        ...ignoreExclude,
+        ...sgignoreExclude,
+    }
+    const excludePatterns = Object.keys(mergedExclude).filter(key => mergedExclude[key] === true)
+    return `{${excludePatterns.join(',')}}`
+}
+
+async function readIgnoreFile(uri: vscode.Uri): Promise<IgnoreRecord> {
+    const ignore: IgnoreRecord = {}
+    try {
+        const data = await vscode.workspace.fs.readFile(uri)
+        for (let line of Buffer.from(data).toString('utf-8').split('\n')) {
+            if (line.startsWith('!')) {
+                continue
+            }
+
+            // Strip comment and trailing whitespace.
+            line = line.replace(/\s*(#.*)?$/, '')
+
+            if (line === '') {
+                continue
+            }
+
+            if (line.endsWith('/')) {
+                line = line.slice(0, -1)
+            }
+            if (!line.startsWith('/') && !line.startsWith('**/')) {
+                line = `**/${line}`
+            }
+            ignore[line] = true
+        }
+    } catch {}
+    return ignore
+}
+
+/**
+ * Dispose all file watchers and clear caches. Call this when the extension is deactivated.
+ */
+function disposeFileWatchers(): void {
+    for (const watcher of fileWatchers.values()) {
+        watcher.dispose()
+    }
+    fileWatchers.clear()
+    excludeCache.clear()
+}
+
 export async function isUriIgnoredByContextFilterWithNotification(
     uri: vscode.Uri,
     feature: CodyIgnoreFeature
@@ -12,3 +166,20 @@ export async function isUriIgnoredByContextFilterWithNotification(
     }
     return isIgnored
 }
+
+/**
+ * Initialize the ContextFiltersProvider with exclude pattern getter.
+ * Returns a disposable that cleans up the configuration when disposed.
+ */
+export function initializeContextFiltersProvider(): vscode.Disposable {
+    // Set up exclude pattern getter for ContextFiltersProvider
+    ContextFiltersProvider.excludePatternGetter = {
+        getExcludePattern,
+        getWorkspaceFolder: (uri: vscode.Uri) => vscode.workspace.getWorkspaceFolder(uri) ?? null,
+    }
+
+    // Return disposable that cleans up the configuration
+    return {
+        dispose: disposeFileWatchers,
+    }
+}