Index notes in folders created, moved or renamed outside VS Code (#1724)

VS Code reports a folder created, deleted, moved or renamed as one event
for the folder, and on Linux often doesn't report the files written into
a new folder before it is watched. Foam's watcher only matched note and
attachment extensions, so it dropped the folder event and never saw those
notes; a renamed folder also left its old notes in the index.

Watch folders too: a created folder is expanded into the files it
contains, and a deleted folder removes the resources under it.


Claude-Session: https://claude.ai/code/session_01EX3EnAE7eqkcteJi29pqJr

Co-authored-by: Claude <noreply@anthropic.com>

Author: riccardoferretti

packages/foam-core/src/model/foam.test.ts

@@ -139,6 +139,34 @@ describe('bootstrap file-watching', () => {
     }
   });
 
+  it('removes the notes under a deleted folder', async () => {
+    // VS Code reports a folder deleted, or moved or renamed away, as one event
+    // for the folder, with no events for the files it contained
+    const { watcher, foam } = await bootstrapWithWatcher(new CountingMatcher());
+
+    try {
+      for (const path of [
+        '/workspace/folder/a.md',
+        '/workspace/folder/nested/b.md',
+        '/workspace/folder.md',
+        '/workspace/folder-sibling/c.md',
+      ]) {
+        watcher.fireCreate(URI.file(path));
+      }
+      await flush(DEBOUNCE_SETTLE_MS);
+
+      watcher.fireDelete(URI.file('/workspace/folder'));
+
+      const remaining = foam.workspace.list().map(r => r.uri.path);
+      expect(remaining.sort()).toEqual([
+        '/workspace/folder-sibling/c.md',
+        '/workspace/folder.md',
+      ]);
+    } finally {
+      foam.dispose();
+    }
+  });
+
   it('does not refresh the matcher for creates after dispose', async () => {
     const matcher = new CountingMatcher();
     const { watcher, foam } = await bootstrapWithWatcher(matcher);

packages/foam-core/src/model/foam.ts

@@ -106,7 +106,17 @@ export const bootstrap = async (
 
     subscriptions.push(
       watcher.onDidDelete(uri => {
-        workspace.delete(uri);
+        if (workspace.delete(uri)) {
+          return;
+        }
+        // Not a resource, so possibly a folder: a watcher may report a folder
+        // deleted, moved or renamed as one event, without its files
+        const folderPrefix = uri.path.endsWith('/') ? uri.path : uri.path + '/';
+        for (const resource of workspace.list()) {
+          if (resource.uri.path.startsWith(folderPrefix)) {
+            workspace.delete(resource.uri);
+          }
+        }
       })
     );
   }

packages/foam-core/src/services/datastore.ts

@@ -50,7 +50,9 @@ export interface IDataStore {
 
 export interface IWatcher {
   onDidChange: Event<URI>;
+  /** Fires for each created file, including those inside a created folder */
   onDidCreate: Event<URI>;
+  /** Fires for a deleted file, or for a deleted folder without its files */
   onDidDelete: Event<URI>;
 }
 

packages/foam-vscode/src/extension.ts

@@ -7,6 +7,8 @@ import {
   commands,
   TextEditor,
   RelativePattern,
+  FileType,
+  Uri,
 } from 'vscode';
 import {
   MarkdownResourceProvider,
@@ -99,7 +101,28 @@ export async function activate(context: ExtensionContext) {
           new RelativePattern(folder.uri, watchGlob)
         )
       ),
-      workspace.onDidSaveTextDocument
+      workspace.onDidSaveTextDocument,
+      {
+        watchers: workspace.workspaceFolders.map(folder =>
+          workspace.createFileSystemWatcher(
+            new RelativePattern(folder.uri, '**/*'),
+            false,
+            true,
+            false
+          )
+        ),
+        listFilesInFolder: async (uri: Uri) => {
+          try {
+            const stat = await workspace.fs.stat(uri);
+            return stat.type & FileType.Directory
+              ? await workspace.findFiles(new RelativePattern(uri, watchGlob))
+              : [];
+          } catch {
+            // Already gone again
+            return [];
+          }
+        },
+      }
     );
     context.subscriptions.push(watcher);
     // Attributes the workspace load time to reading vs parsing vs neither, so

packages/foam-vscode/src/vscode/services/watcher.spec.ts

@@ -0,0 +1,56 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  getUriInWorkspace,
+  waitForNoteInFoamWorkspace,
+  waitForNoteRemovedFromFoamWorkspace,
+} from '../../test/test-utils-vscode';
+import { randomString, wait } from '../../test/test-utils';
+
+/**
+ * VS Code reports a folder moved or renamed as a single event for the folder,
+ * without events for the files inside it. The folders here are changed with
+ * Node's fs, as a terminal, a file manager or git would do, rather than
+ * through VS Code.
+ */
+describe('Watching folders changed outside VS Code', () => {
+  it('indexes the notes in a folder moved into the workspace', async () => {
+    const name = `moved-in-${randomString()}`;
+    const folder = getUriInWorkspace(name);
+    // Outside the workspace folder, on the same file system so rename works
+    const outside = path.join(folder.toFsPath(), '..', '..', `.${name}`);
+    const note = folder.joinPath('note.md');
+    try {
+      fs.mkdirSync(outside);
+      fs.writeFileSync(path.join(outside, 'note.md'), '# Note');
+      fs.renameSync(outside, folder.toFsPath());
+
+      await waitForNoteInFoamWorkspace(note);
+    } finally {
+      fs.rmSync(outside, { recursive: true, force: true });
+      fs.rmSync(folder.toFsPath(), { recursive: true, force: true });
+    }
+  });
+
+  it('re-indexes the notes in a renamed folder', async () => {
+    const before = getUriInWorkspace(`renamed-${randomString()}`);
+    const after = getUriInWorkspace(`renamed-${randomString()}`);
+    const noteBefore = before.joinPath('note.md');
+    const noteAfter = after.joinPath('note.md');
+    try {
+      fs.mkdirSync(before.toFsPath());
+      // Let the watcher pick up the folder, so the note's own event is seen
+      await wait(1000);
+      fs.writeFileSync(noteBefore.toFsPath(), '# Note');
+      await waitForNoteInFoamWorkspace(noteBefore);
+
+      fs.renameSync(before.toFsPath(), after.toFsPath());
+
+      await waitForNoteInFoamWorkspace(noteAfter);
+      await waitForNoteRemovedFromFoamWorkspace(noteBefore);
+    } finally {
+      fs.rmSync(before.toFsPath(), { recursive: true, force: true });
+      fs.rmSync(after.toFsPath(), { recursive: true, force: true });
+    }
+  });
+});

packages/foam-vscode/src/vscode/services/watcher.ts

@@ -2,11 +2,24 @@ import { IDisposable } from '@foam/core';
 import { Emitter } from '@foam/core';
 import { IWatcher } from '@foam/core';
 import { URI } from '@foam/core';
-import { Event, FileSystemWatcher, TextDocument } from 'vscode';
+import { Event, FileSystemWatcher, TextDocument, Uri } from 'vscode';
 import { fromVsCodeUri } from '../utils/vsc-utils';
 
 const DEBOUNCE_MS = 100;
 
+/**
+ * VS Code reports a folder created, deleted, moved or renamed as one event for
+ * the folder, and may not report the files inside it at all (e.g. on Linux,
+ * files written before the new folder is watched). Watchers matching folders
+ * make up for it: a created folder is expanded into its files, and a deleted
+ * one is forwarded for the consumer to expand.
+ */
+export interface FolderWatch {
+  watchers: FileSystemWatcher[];
+  /** The files to report as created under `uri`, or none if it isn't a folder */
+  listFilesInFolder: (uri: Uri) => Promise<Uri[]>;
+}
+
 export class VsCodeWatcher implements IWatcher, IDisposable {
   public onDidCreateEmitter = new Emitter<URI>();
   public onDidChangeEmitter = new Emitter<URI>();
@@ -20,15 +33,17 @@ export class VsCodeWatcher implements IWatcher, IDisposable {
 
   constructor(
     vsCodeWatcher: FileSystemWatcher | FileSystemWatcher[],
-    onDidSaveTextDocument?: Event<TextDocument>
+    onDidSaveTextDocument?: Event<TextDocument>,
+    folderWatch?: FolderWatch
   ) {
     // Multiple watchers support multi-root workspaces, where each folder gets
     // its own scoped RelativePattern watcher.
-    this.vsCodeWatchers = Array.isArray(vsCodeWatcher)
+    const fileWatchers = Array.isArray(vsCodeWatcher)
       ? vsCodeWatcher
       : [vsCodeWatcher];
+    this.vsCodeWatchers = [...fileWatchers, ...(folderWatch?.watchers ?? [])];
 
-    for (const w of this.vsCodeWatchers) {
+    for (const w of fileWatchers) {
       w.onDidCreate(uri =>
         this.onDidCreateEmitter.fire(fromVsCodeUri(uri))
       );
@@ -38,6 +53,17 @@ export class VsCodeWatcher implements IWatcher, IDisposable {
       );
     }
     onDidSaveTextDocument?.(doc => this.fireChange(fromVsCodeUri(doc.uri)));
+
+    for (const w of folderWatch?.watchers ?? []) {
+      w.onDidCreate(async uri => {
+        for (const file of await folderWatch.listFilesInFolder(uri)) {
+          this.onDidCreateEmitter.fire(fromVsCodeUri(file));
+        }
+      });
+      w.onDidDelete(uri =>
+        this.onDidDeleteEmitter.fire(fromVsCodeUri(uri))
+      );
+    }
   }
 
   private fireChange(uri: URI): void {