@platformos/platformos-language-server-common 0.0.12 → 0.0.13

package/src/server/startServer.ts

@@ -10,7 +10,7 @@ import {
   SourceCodeType,
   UriString,
 } from '@platformos/platformos-check-common';
-import { TranslationProvider } from '@platformos/platformos-common';
+import { TranslationProvider, isPage } from '@platformos/platformos-common';
 import {
   Connection,
   FileChangeType,
@@ -44,6 +44,7 @@ import {
   AppGraphRootRequest,
 } from '../types';
 import { debounce } from '../utils';
+import { SearchPathsLoader } from '../utils/searchPaths';
 import { VERSION } from '../version';
 import { CachedFileSystem } from './CachedFileSystem';
 import { Configuration, INCLUDE_FILES_FROM_DISK } from './Configuration';
@@ -55,6 +56,13 @@ import { URI } from 'vscode-uri';
 
 const defaultLogger = () => {};
 
+/**
+ * When a file-watcher batch contains this many page-file changes, we
+ * assume a bulk operation (git checkout, branch switch, stash pop) and
+ * fully rebuild the route table instead of applying incremental updates.
+ */
+const BULK_PAGE_CHANGE_THRESHOLD = 10;
+
 /**
  * The `git:` VFS does not support the `fs.readDirectory` call and makes most things break.
  * `git` URIs are the ones you'd encounter when doing a git diff in VS Code. They're not
@@ -108,11 +116,13 @@ export function startServer(
   const diagnosticsManager = new DiagnosticsManager(connection);
   const documentsLocator = new DocumentsLocator(fs);
   const translationProvider = new TranslationProvider(fs);
+  const searchPathsCache = new SearchPathsLoader(fs);
   const documentLinksProvider = new DocumentLinksProvider(
     documentManager,
     findAppRootURI,
     documentsLocator,
     translationProvider,
+    searchPathsCache,
   );
   const codeActionsProvider = new CodeActionsProvider(documentManager, diagnosticsManager);
   const onTypeFormattingProvider = new OnTypeFormattingProvider(
@@ -161,6 +171,7 @@ export function startServer(
       jsonValidationSet,
       appGraphManager,
       includeFilesFromDisk: () => configuration[INCLUDE_FILES_FROM_DISK],
+      getRouteTable: () => definitionsProvider.getRouteTable(),
     }),
     100,
   );
@@ -215,7 +226,14 @@ export function startServer(
     return (documentManager.get(defaultLocaleFileUri) as AugmentedJsonSourceCode) ?? null;
   }
 
-  const definitionsProvider = new DefinitionProvider(documentManager, getDefaultLocaleSourceCode);
+  const definitionsProvider = new DefinitionProvider(
+    documentManager,
+    getDefaultLocaleSourceCode,
+    fs,
+    findAppRootURI,
+    documentsLocator,
+    searchPathsCache,
+  );
   const jsonLanguageService = new JSONLanguageService(documentManager, jsonValidationSet);
   const cssLanguageService = new CSSLanguageService(documentManager);
   const completionsProvider = new CompletionsProvider({
@@ -342,6 +360,9 @@ export function startServer(
         {
           globPattern: '**/*.css',
         },
+        {
+          globPattern: '**/app/config.yml',
+        },
       ],
     });
   });
@@ -388,7 +409,11 @@ export function startServer(
       cssLanguageService.change(uri, params.contentChanges[0].text, version);
       return;
     }
-    documentManager.change(uri, params.contentChanges[0].text, version);
+    const text = params.contentChanges[0].text;
+    documentManager.change(uri, text, version);
+    if (isPage(uri)) {
+      definitionsProvider.onPageFileChanged(uri, text);
+    }
     if (await configuration.shouldCheckOnChange()) {
       runChecks([uri]);
     } else {
@@ -400,6 +425,15 @@ export function startServer(
   connection.onDidSaveTextDocument(async (params) => {
     if (hasUnsupportedDocument(params)) return;
     const { uri } = params.textDocument;
+
+    // onDidChangeWatchedFiles also fires for in-editor saves, but it arrives after
+    // onDidSaveTextDocument. Invalidate the search-paths cache here immediately so
+    // that go-to-definition requests triggered by the same save don't see stale data
+    // while waiting for the file-watcher notification.
+    if (uri.endsWith('/app/config.yml')) {
+      searchPathsCache.invalidate();
+    }
+
     if (await configuration.shouldCheckOnSave()) {
       runChecks([uri]);
     }
@@ -534,6 +568,16 @@ export function startServer(
     if (params.changes.length === 0) return;
 
     const triggerUris = params.changes.map((change) => change.uri);
+
+    // When many page files change at once (e.g., git checkout, branch switch, stash pop),
+    // incremental updates aren't reliable — files not open in the editor won't get
+    // individual onDidChangeTextDocument events. VS Code reports branch-switch changes
+    // as FileChangeType.Changed, so we count all change types.
+    const bulkPageChanges = params.changes.filter((c) => isPage(c.uri));
+    if (bulkPageChanges.length >= BULK_PAGE_CHANGE_THRESHOLD) {
+      definitionsProvider.invalidateRouteTable();
+    }
+
     const updates: Promise<any>[] = [];
     for (const change of params.changes) {
       // App Check config changes should clear the config cache
@@ -542,6 +586,21 @@ export function startServer(
         continue;
       }
 
+      // app/config.yml changes should clear expanded search paths cache
+      // and force re-check of all open documents.
+      // Note: readFile for config.yml bypasses the CachedFileSystem cache,
+      // so we don't need to invalidate it — reads are always fresh.
+      if (change.uri.endsWith('/app/config.yml')) {
+        documentsLocator.clearExpandedPathsCache();
+        searchPathsCache.invalidate();
+
+        // Ensure open liquid files are re-checked with the new search paths
+        for (const doc of documentManager.openDocuments) {
+          triggerUris.push(doc.uri);
+        }
+        continue;
+      }
+
       // Rename cache invalidation is handled by onDidRenameFiles
       if (documentManager.hasRecentRename(change.uri)) {
         documentManager.clearRecentRename(change.uri);
@@ -556,7 +615,14 @@ export function startServer(
           fs.stat.invalidate(change.uri);
           appGraphManager.create(change.uri);
           // If a file is created under out feet, we update its contents.
-          updates.push(documentManager.changeFromDisk(change.uri));
+          updates.push(
+            documentManager.changeFromDisk(change.uri).then(() => {
+              if (isPage(change.uri)) {
+                const doc = documentManager.get(change.uri);
+                if (doc) definitionsProvider.onPageFileChanged(change.uri, doc.source);
+              }
+            }),
+          );
           break;
 
         case FileChangeType.Changed:
@@ -568,7 +634,20 @@ export function startServer(
           // If it is open, then we don't need to update it because the document manager
           // will have the version from the editor.
           if (documentManager.get(change.uri)?.version === undefined) {
-            updates.push(documentManager.changeFromDisk(change.uri));
+            updates.push(
+              documentManager.changeFromDisk(change.uri).then(() => {
+                if (isPage(change.uri)) {
+                  const doc = documentManager.get(change.uri);
+                  if (doc) definitionsProvider.onPageFileChanged(change.uri, doc.source);
+                }
+              }),
+            );
+          } else if (isPage(change.uri)) {
+            // File is open in editor but changed externally (e.g. git checkout).
+            // The doc manager already has the editor version, but the route table
+            // may be stale — update it from whatever the doc manager holds.
+            const doc = documentManager.get(change.uri);
+            if (doc) definitionsProvider.onPageFileChanged(change.uri, doc.source);
           }
           break;
 
@@ -578,6 +657,7 @@ export function startServer(
           fs.readFile.invalidate(change.uri);
           fs.stat.invalidate(change.uri);
           appGraphManager.delete(change.uri);
+          if (isPage(change.uri)) definitionsProvider.onPageFileDeleted(change.uri);
           // If a file is deleted, it's removed from the document manager
           documentManager.delete(change.uri);
           break;

package/src/utils/searchPaths.spec.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, vi } from 'vitest';
+import { URI } from 'vscode-uri';
+import { SearchPathsLoader } from './searchPaths';
+
+const rootUri = URI.parse('file:///project');
+const configUri = 'file:///project/app/config.yml';
+
+function createMockFs(configContent: string | null) {
+  return {
+    readFile: vi.fn(async (uri: string) => {
+      if (uri === configUri && configContent !== null) return configContent;
+      throw new Error(`File not found: ${uri}`);
+    }),
+    readDirectory: vi.fn(async () => []),
+    stat: vi.fn(async () => ({ type: 1, size: 0 })),
+  };
+}
+
+describe('SearchPathsLoader', () => {
+  it('should cache results across calls for the same root', async () => {
+    const fs = createMockFs('theme_search_paths:\n  - theme/dress');
+    const loader = new SearchPathsLoader(fs);
+
+    const result1 = await loader.get(rootUri);
+    expect(result1).toEqual(['theme/dress']);
+
+    const result2 = await loader.get(rootUri);
+    expect(result2).toEqual(['theme/dress']);
+
+    // readFile should only be called once — second call served from cache
+    expect(fs.readFile).toHaveBeenCalledTimes(1);
+  });
+
+  it('should return fresh results after invalidate()', async () => {
+    let configContent = 'theme_search_paths:\n  - theme/dress';
+    const fs = {
+      readFile: vi.fn(async (uri: string) => {
+        if (uri === configUri) return configContent;
+        throw new Error(`File not found: ${uri}`);
+      }),
+      readDirectory: vi.fn(async () => []),
+      stat: vi.fn(async () => ({ type: 1, size: 0 })),
+    };
+    const loader = new SearchPathsLoader(fs);
+
+    const result1 = await loader.get(rootUri);
+    expect(result1).toEqual(['theme/dress']);
+
+    // Config changes externally
+    configContent = 'theme_search_paths:\n  - theme/simple';
+
+    // Without invalidation, still returns cached result
+    const result2 = await loader.get(rootUri);
+    expect(result2).toEqual(['theme/dress']);
+
+    // After invalidation, reads fresh
+    loader.invalidate();
+    const result3 = await loader.get(rootUri);
+    expect(result3).toEqual(['theme/simple']);
+
+    expect(fs.readFile).toHaveBeenCalledTimes(2);
+  });
+
+  it('should return null when config has no search paths', async () => {
+    const fs = createMockFs('some_other_key: value');
+    const loader = new SearchPathsLoader(fs);
+
+    const result = await loader.get(rootUri);
+    expect(result).toBeNull();
+  });
+
+  it('should return null when config.yml does not exist', async () => {
+    const fs = createMockFs(null);
+    const loader = new SearchPathsLoader(fs);
+
+    const result = await loader.get(rootUri);
+    expect(result).toBeNull();
+  });
+
+  it('should cache per root URI independently', async () => {
+    const root2 = URI.parse('file:///other-project');
+    const config2Uri = 'file:///other-project/app/config.yml';
+    const fs = {
+      readFile: vi.fn(async (uri: string) => {
+        if (uri === configUri) return 'theme_search_paths:\n  - theme/a';
+        if (uri === config2Uri) return 'theme_search_paths:\n  - theme/b';
+        throw new Error(`File not found: ${uri}`);
+      }),
+      readDirectory: vi.fn(async () => []),
+      stat: vi.fn(async () => ({ type: 1, size: 0 })),
+    };
+    const loader = new SearchPathsLoader(fs);
+
+    const result1 = await loader.get(rootUri);
+    const result2 = await loader.get(root2);
+
+    expect(result1).toEqual(['theme/a']);
+    expect(result2).toEqual(['theme/b']);
+    expect(fs.readFile).toHaveBeenCalledTimes(2);
+  });
+});

package/src/utils/searchPaths.ts

@@ -0,0 +1,32 @@
+import { AbstractFileSystem, loadSearchPaths } from '@platformos/platformos-common';
+import { URI } from 'vscode-uri';
+
+/**
+ * Cached loader for theme_search_paths from app/config.yml.
+ *
+ * Caches per root URI so that repeated calls (document links, definitions,
+ * checks) within the same editor session don't re-read and re-parse the
+ * config file on every invocation.
+ *
+ * Call `invalidate()` when app/config.yml changes on disk — the file watcher
+ * in startServer.ts handles this. This is the only reliable invalidation
+ * point because config.yml changes may come from external tools (vim, CLI)
+ * that don't trigger editor-level change events.
+ */
+export class SearchPathsLoader {
+  private cache = new Map<string, Promise<string[] | null>>();
+
+  constructor(private fs: AbstractFileSystem) {}
+
+  get(rootUri: URI): Promise<string[] | null> {
+    const key = rootUri.toString();
+    if (!this.cache.has(key)) {
+      this.cache.set(key, loadSearchPaths(this.fs, rootUri));
+    }
+    return this.cache.get(key)!;
+  }
+
+  invalidate(): void {
+    this.cache.clear();
+  }
+}