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

package/src/definitions/providers/PageRouteDefinitionProvider.ts

@@ -0,0 +1,250 @@
+import { LiquidHtmlNode, HtmlElement, NodeTypes, TextNode } from '@platformos/liquid-html-parser';
+import { RouteTable, AbstractFileSystem } from '@platformos/platformos-common';
+import {
+  SourceCodeType,
+  shouldSkipUrl,
+  isValuedAttrNode,
+  getAttrName,
+  extractUrlPattern,
+  getEffectiveMethod,
+  buildVariableMap,
+  ValuedAttrNode,
+} from '@platformos/platformos-check-common';
+import { URI } from 'vscode-uri';
+import {
+  DefinitionParams,
+  DefinitionLink,
+  Range,
+  LocationLink,
+} from 'vscode-languageserver-protocol';
+import { DocumentManager } from '../../documents';
+import { BaseDefinitionProvider } from '../BaseDefinitionProvider';
+
+function getTagName(node: LiquidHtmlNode): string | null {
+  if (node.type !== NodeTypes.HtmlElement) return null;
+  const el = node as HtmlElement;
+  if (el.name.length !== 1) return null;
+  if ((el.name[0] as LiquidHtmlNode).type !== NodeTypes.TextNode) return null;
+  return (el.name[0] as TextNode).value;
+}
+
+/** Tag name → attribute that holds the URL */
+const TAG_URL_ATTR: Record<string, string> = {
+  a: 'href',
+  form: 'action',
+};
+
+/**
+ * Find the URL-bearing attribute on an element.
+ * For <a> looks for href, for <form> looks for action.
+ */
+function findUrlAttr(el: HtmlElement, tagName: string): ValuedAttrNode | null {
+  const urlAttrName = TAG_URL_ATTR[tagName];
+  if (!urlAttrName) return null;
+  const attr = (el.attributes as LiquidHtmlNode[]).find(
+    (a) => isValuedAttrNode(a) && getAttrName(a) === urlAttrName,
+  );
+  if (!attr || !isValuedAttrNode(attr)) return null;
+  return attr;
+}
+
+export class PageRouteDefinitionProvider implements BaseDefinitionProvider {
+  private routeTable: RouteTable;
+  private builtRoots = new Set<string>();
+
+  constructor(
+    private documentManager: DocumentManager,
+    private fs: AbstractFileSystem,
+    private findAppRootURI: (uri: string) => Promise<string | null>,
+  ) {
+    this.routeTable = new RouteTable(fs);
+  }
+
+  /** Returns the shared route table (may trigger a build if not yet built). */
+  getRouteTable(): RouteTable {
+    return this.routeTable;
+  }
+
+  private async ensureBuilt(uri: string): Promise<boolean> {
+    const rootUri = await this.findAppRootURI(uri);
+    if (!rootUri) return false;
+
+    if (!this.builtRoots.has(rootUri)) {
+      await this.routeTable.build(URI.parse(rootUri));
+      this.builtRoots.add(rootUri);
+    }
+    return true;
+  }
+
+  /**
+   * Called by the LSP when a page file changes on disk or in the editor.
+   * Keeps the route table in sync without a full rebuild.
+   * Callers are responsible for filtering to page URIs via isPage().
+   */
+  onPageFileChanged(uri: string, content: string): void {
+    this.routeTable.updateFile(uri, content);
+  }
+
+  /**
+   * Called by the LSP when a page file is deleted.
+   * Callers are responsible for filtering to page URIs via isPage().
+   */
+  onPageFileDeleted(uri: string): void {
+    this.routeTable.removeFile(uri);
+  }
+
+  /**
+   * Invalidate the cached build state so the next definition request triggers
+   * a full route-table rebuild. Call this after bulk file changes that bypass
+   * incremental updates (e.g., git checkout, branch switch, stash pop).
+   */
+  invalidate(): void {
+    this.builtRoots.clear();
+    this.routeTable = new RouteTable(this.fs);
+  }
+
+  async definitions(
+    params: DefinitionParams,
+    node: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+  ): Promise<DefinitionLink[]> {
+    const sourceCode = this.documentManager.get(params.textDocument.uri);
+    if (!sourceCode) return [];
+    const doc = sourceCode.textDocument;
+
+    const resolved = this.resolveUrlContext(node, ancestors);
+    if (!resolved) return [];
+
+    const { urlAttr, method, element } = resolved;
+
+    // Build a variable map from {% assign %} tags that precede the current element.
+    // This ensures that when a variable is reassigned, each usage sees only the
+    // assigns that come before it in document order.
+    let variableMap: Map<string, string> | undefined;
+    if (
+      sourceCode.type === SourceCodeType.LiquidHtml &&
+      !(sourceCode.ast instanceof Error) &&
+      'children' in sourceCode.ast &&
+      Array.isArray(sourceCode.ast.children)
+    ) {
+      variableMap = buildVariableMap(sourceCode.ast.children, element.position.start);
+    }
+
+    const urlPattern = extractUrlPattern(urlAttr, variableMap);
+    if (urlPattern === null || shouldSkipUrl(urlPattern)) return [];
+
+    const ready = await this.ensureBuilt(params.textDocument.uri);
+    if (!ready) return [];
+
+    const matches = this.routeTable.match(urlPattern, method);
+    if (matches.length === 0) return [];
+
+    const originRange = Range.create(
+      doc.positionAt(element.position.start),
+      doc.positionAt(urlAttr.value[urlAttr.value.length - 1].position.end),
+    );
+
+    const results: DefinitionLink[] = [];
+    for (const entry of matches) {
+      const targetRange = Range.create(0, 0, 0, 0);
+      results.push(LocationLink.create(entry.uri, targetRange, targetRange, originRange));
+    }
+
+    return results;
+  }
+
+  /**
+   * Resolve the URL context from the cursor position.
+   * Activates when cursor is on:
+   * - The tag name (e.g. `a` in `<a href="...">`)
+   * - The URL-bearing attribute name or value (e.g. `href` or `/about` for <a>, `action` for <form>)
+   * - Inside a Liquid expression within the URL attribute (e.g. `{{ url }}` inside href)
+   * Does NOT activate on unrelated attributes (e.g. `class` in `<a class="x" href="/about">`).
+   */
+  private resolveUrlContext(
+    node: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+  ): { urlAttr: ValuedAttrNode; method: string; element: HtmlElement } | null {
+    // Case 1: node is the HtmlElement itself (cursor on tag name)
+    if (node.type === NodeTypes.HtmlElement) {
+      return this.resolveFromElement(node as HtmlElement);
+    }
+
+    // Case 2: node is a valued attribute — only activate if it's the URL attribute
+    if (isValuedAttrNode(node)) {
+      const element = this.findElementAncestor(ancestors);
+      if (!element) return null;
+      return this.resolveFromUrlAttr(node, element as HtmlElement);
+    }
+
+    // Case 3: node is inside a valued attribute (TextNode, LiquidVariableOutput, VariableLookup, etc.)
+    const attrAncestor = ancestors.find(isValuedAttrNode);
+    if (attrAncestor) {
+      const element = this.findElementAncestor(ancestors);
+      if (!element) return null;
+      return this.resolveFromUrlAttr(attrAncestor, element as HtmlElement);
+    }
+
+    // Case 4: TextNode directly under HtmlElement (e.g., tag name text)
+    if (node.type === NodeTypes.TextNode) {
+      const parentElement = ancestors[ancestors.length - 1];
+      if (parentElement && parentElement.type === NodeTypes.HtmlElement) {
+        return this.resolveFromElement(parentElement as HtmlElement);
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Only resolve if the given attribute is the URL-bearing attribute (href/action)
+   * for the parent element.
+   */
+  private resolveFromUrlAttr(
+    attr: ValuedAttrNode,
+    element: HtmlElement,
+  ): { urlAttr: ValuedAttrNode; method: string; element: HtmlElement } | null {
+    const tagName = getTagName(element);
+    if (!tagName) return null;
+
+    const urlAttrName = TAG_URL_ATTR[tagName];
+    if (!urlAttrName) return null;
+
+    // Check that the cursor's attribute IS the URL attribute
+    const attrName = getAttrName(attr);
+    if (attrName !== urlAttrName) return null;
+
+    const method = this.getMethodForElement(tagName, element);
+    if (!method) return null;
+
+    return { urlAttr: attr, method, element };
+  }
+
+  private resolveFromElement(
+    element: HtmlElement,
+  ): { urlAttr: ValuedAttrNode; method: string; element: HtmlElement } | null {
+    const tagName = getTagName(element);
+    if (!tagName) return null;
+
+    const urlAttr = findUrlAttr(element, tagName);
+    if (!urlAttr) return null;
+
+    const method = this.getMethodForElement(tagName, element);
+    if (!method) return null;
+
+    return { urlAttr, method, element };
+  }
+
+  private findElementAncestor(ancestors: LiquidHtmlNode[]): LiquidHtmlNode | null {
+    for (let i = ancestors.length - 1; i >= 0; i--) {
+      if (ancestors[i].type === NodeTypes.HtmlElement) return ancestors[i];
+    }
+    return null;
+  }
+
+  private getMethodForElement(tagName: string, element: HtmlElement): string | null {
+    if (tagName === 'a') return 'get';
+    if (tagName === 'form') return getEffectiveMethod(element);
+    return null;
+  }
+}

package/src/definitions/providers/RenderPartialDefinitionProvider.spec.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, assert } from 'vitest';
+import { toLiquidHtmlAST } from '@platformos/liquid-html-parser';
+import { findCurrentNode } from '@platformos/platformos-check-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+import { DocumentsLocator } from '@platformos/platformos-common';
+import { DefinitionParams, Position } from 'vscode-languageserver-protocol';
+import { DocumentManager } from '../../documents';
+import { SearchPathsLoader } from '../../utils/searchPaths';
+import { RenderPartialDefinitionProvider } from './RenderPartialDefinitionProvider';
+
+const rootUri = 'file:///project';
+const uriString = 'file:///project/app/views/pages/index.liquid';
+
+function setup(files: Record<string, string>) {
+  const documentManager = new DocumentManager();
+  const mockFs = new MockFileSystem(files);
+  const provider = new RenderPartialDefinitionProvider(
+    documentManager,
+    new DocumentsLocator(mockFs),
+    new SearchPathsLoader(mockFs),
+    async () => rootUri,
+  );
+  return { documentManager, provider };
+}
+
+async function getDefinitions(source: string, cursorOffset: number, files: Record<string, string>) {
+  const { documentManager, provider } = setup(files);
+  documentManager.open(uriString, source, 1);
+
+  const ast = toLiquidHtmlAST(source);
+  const [node, ancestors] = findCurrentNode(ast, cursorOffset);
+  const params: DefinitionParams = {
+    textDocument: { uri: uriString },
+    position: Position.create(0, cursorOffset),
+  };
+
+  return provider.definitions(params, node, ancestors);
+}
+
+describe('RenderPartialDefinitionProvider', () => {
+  describe('render tag', () => {
+    it('should resolve render partials', async () => {
+      const result = await getDefinitions("{% render 'card' %}", 12, {
+        'project/app/views/partials/card.liquid': 'card content',
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result[0].targetUri).toBe('file:///project/app/views/partials/card.liquid');
+    });
+
+    it('should NOT use search paths for regular render tags', async () => {
+      const result = await getDefinitions("{% render 'card' %}", 12, {
+        'project/app/config.yml': 'theme_search_paths:\n  - theme/dress',
+        'project/app/views/partials/theme/dress/card.liquid': 'dress card',
+      });
+
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('theme_render_rc tag', () => {
+    it('should resolve via theme_search_paths', async () => {
+      const result = await getDefinitions("{% theme_render_rc 'card' %}", 20, {
+        'project/app/config.yml': 'theme_search_paths:\n  - theme/dress\n  - theme/simple',
+        'project/app/views/partials/theme/dress/card.liquid': 'dress card',
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result[0].targetUri).toBe(
+        'file:///project/app/views/partials/theme/dress/card.liquid',
+      );
+    });
+
+    it('should fallback to standard resolution when no config exists', async () => {
+      const result = await getDefinitions("{% theme_render_rc 'card' %}", 20, {
+        'project/app/views/partials/card.liquid': 'default card',
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result[0].targetUri).toBe('file:///project/app/views/partials/card.liquid');
+    });
+
+    it('should resolve inside {% liquid %} blocks', async () => {
+      const source = `{% liquid
+  theme_render_rc 'components/atoms/heading', content: 'text'
+%}`;
+      const offset = source.indexOf('components/atoms/heading');
+      const { documentManager, provider } = setup({
+        'project/app/config.yml': "theme_search_paths:\n  - ''\n  - modules/components",
+        'project/modules/components/public/views/partials/components/atoms/heading.liquid':
+          'heading',
+      });
+      documentManager.open(uriString, source, 1);
+
+      const ast = toLiquidHtmlAST(source);
+      const [node, ancestors] = findCurrentNode(ast, offset);
+      const params: DefinitionParams = {
+        textDocument: { uri: uriString },
+        position: Position.create(1, 20),
+      };
+
+      const result = await provider.definitions(params, node, ancestors);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].targetUri).toBe(
+        'file:///project/modules/components/public/views/partials/components/atoms/heading.liquid',
+      );
+    });
+  });
+
+  describe('function tag', () => {
+    it('should resolve function partials', async () => {
+      const result = await getDefinitions("{% function result = 'commands/apply' %}", 24, {
+        'project/app/lib/commands/apply.liquid': 'apply content',
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result[0].targetUri).toBe('file:///project/app/lib/commands/apply.liquid');
+    });
+  });
+
+  describe('graphql tag', () => {
+    it('should resolve graphql references', async () => {
+      const result = await getDefinitions("{% graphql g = 'users/search' %}", 18, {
+        'project/app/graphql/users/search.graphql': 'query { }',
+      });
+
+      expect(result).toHaveLength(1);
+      expect(result[0].targetUri).toBe('file:///project/app/graphql/users/search.graphql');
+    });
+  });
+
+  describe('non-matching nodes', () => {
+    it('should return empty for non-string nodes', async () => {
+      const result = await getDefinitions("{% assign x = 'hello' %}", 3, {});
+
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('search path cache invalidation', () => {
+    it('returns stale result when cache is not invalidated after config change', async () => {
+      // Regression test: SearchPathsLoader caches results across calls.
+      // Without explicit invalidate(), a config change is not picked up.
+      const files: Record<string, string> = {
+        'project/app/config.yml': 'theme_search_paths:\n  - theme/dress',
+        'project/app/views/partials/theme/dress/card.liquid': 'dress card',
+        'project/app/views/partials/theme/simple/card.liquid': 'simple card',
+      };
+      const mockFs = new MockFileSystem(files);
+      const searchPathsCache = new SearchPathsLoader(mockFs);
+      const documentManager = new DocumentManager();
+      const provider = new RenderPartialDefinitionProvider(
+        documentManager,
+        new DocumentsLocator(mockFs),
+        searchPathsCache,
+        async () => rootUri,
+      );
+
+      const source = "{% theme_render_rc 'card' %}";
+      const offset = source.indexOf("'card'") + 1;
+      documentManager.open(uriString, source, 1);
+
+      const ast = toLiquidHtmlAST(source);
+      const [node, ancestors] = findCurrentNode(ast, offset);
+      const params: DefinitionParams = {
+        textDocument: { uri: uriString },
+        position: Position.create(0, offset),
+      };
+
+      // First call: populates the cache with 'theme/dress'
+      const result1 = await provider.definitions(params, node, ancestors);
+      assert(result1.length === 1);
+      expect(result1[0].targetUri).toContain('theme/dress/card.liquid');
+
+      // Simulate config.yml change on disk (mutate mockApp in-place)
+      files['project/app/config.yml'] = 'theme_search_paths:\n  - theme/simple';
+
+      // Without invalidation: cache still returns 'theme/dress' result
+      const result2 = await provider.definitions(params, node, ancestors);
+      assert(result2.length === 1);
+      expect(result2[0].targetUri).toContain('theme/dress/card.liquid');
+
+      // After invalidation: re-reads config and returns 'theme/simple' result
+      searchPathsCache.invalidate();
+      const result3 = await provider.definitions(params, node, ancestors);
+      assert(result3.length === 1);
+      expect(result3[0].targetUri).toContain('theme/simple/card.liquid');
+    });
+  });
+});

package/src/definitions/providers/RenderPartialDefinitionProvider.ts

@@ -0,0 +1,70 @@
+import { LiquidHtmlNode, LiquidString, LiquidTag, NodeTypes } from '@platformos/liquid-html-parser';
+import { DocumentsLocator, DocumentType } from '@platformos/platformos-common';
+import {
+  DefinitionParams,
+  DefinitionLink,
+  Range,
+  LocationLink,
+} from 'vscode-languageserver-protocol';
+import { URI } from 'vscode-uri';
+import { DocumentManager } from '../../documents';
+import { BaseDefinitionProvider } from '../BaseDefinitionProvider';
+import { SearchPathsLoader } from '../../utils/searchPaths';
+
+const TAG_MARKUP_TYPE: Record<string, NodeTypes> = {
+  render: NodeTypes.RenderMarkup,
+  include: NodeTypes.RenderMarkup,
+  theme_render_rc: NodeTypes.RenderMarkup,
+  function: NodeTypes.FunctionMarkup,
+  graphql: NodeTypes.GraphQLMarkup,
+};
+
+export class RenderPartialDefinitionProvider implements BaseDefinitionProvider {
+  constructor(
+    private documentManager: DocumentManager,
+    private documentsLocator: DocumentsLocator,
+    private searchPathsCache: SearchPathsLoader,
+    private findAppRootURI: (uri: string) => Promise<string | null>,
+  ) {}
+
+  async definitions(
+    params: DefinitionParams,
+    node: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+  ): Promise<DefinitionLink[]> {
+    if (node.type !== NodeTypes.String) return [];
+
+    const markup = ancestors.at(-1);
+    const tag = ancestors.at(-2);
+    if (!markup || !tag || tag.type !== NodeTypes.LiquidTag) return [];
+
+    const expectedMarkupType = TAG_MARKUP_TYPE[(tag as LiquidTag).name];
+    if (expectedMarkupType === undefined || markup.type !== expectedMarkupType) return [];
+
+    const rootUri = await this.findAppRootURI(params.textDocument.uri);
+    if (!rootUri) return [];
+
+    const root = URI.parse(rootUri);
+    const searchPaths = await this.searchPathsCache.get(root);
+    const docType = (tag as LiquidTag).name as DocumentType;
+    const fileUri = await this.documentsLocator.locate(
+      root,
+      docType,
+      (node as LiquidString).value,
+      searchPaths,
+    );
+    if (!fileUri) return [];
+
+    const sourceCode = this.documentManager.get(params.textDocument.uri);
+    if (!sourceCode) return [];
+
+    const doc = sourceCode.textDocument;
+    const originRange = Range.create(
+      doc.positionAt(node.position.start),
+      doc.positionAt(node.position.end),
+    );
+    const targetRange = Range.create(0, 0, 0, 0);
+
+    return [LocationLink.create(fileUri, targetRange, targetRange, originRange)];
+  }
+}

package/src/diagnostics/runChecks.ts

@@ -6,6 +6,7 @@ import {
   Reference,
   SourceCodeType,
 } from '@platformos/platformos-check-common';
+import { RouteTable } from '@platformos/platformos-common';
 
 import { DocumentManager } from '../documents';
 import { Dependencies } from '../types';
@@ -22,9 +23,11 @@ export function makeRunChecks(
     jsonValidationSet,
     appGraphManager,
     includeFilesFromDisk,
+    getRouteTable,
   }: Pick<Dependencies, 'fs' | 'loadConfig' | 'platformosDocset' | 'jsonValidationSet'> & {
     appGraphManager?: AppGraphManager;
     includeFilesFromDisk?: () => boolean;
+    getRouteTable?: () => RouteTable | undefined;
   },
 ) {
   return async function runChecks(triggerURIs: string[]): Promise<void> {
@@ -52,6 +55,7 @@ export function makeRunChecks(
         fs,
         platformosDocset,
         jsonValidationSet,
+        routeTable: getRouteTable?.(),
 
         async getReferences(uri: string): Promise<Reference[]> {
           if (!appGraphManager) return [];