@platformos/platformos-language-server-common 0.0.2

package/src/VariableShapeExtractor.ts

@@ -0,0 +1,380 @@
+import {
+  NodeTypes,
+  LiquidHtmlNode,
+  LiquidTag,
+  LiquidExpression,
+  LiquidVariableLookup,
+  NamedTags,
+  TextNode,
+  GraphQLMarkup,
+  GraphQLInlineMarkup,
+  LiquidString,
+  HashAssignMarkup,
+} from '@platformos/liquid-html-parser';
+import { visit, SourceCodeType } from '@platformos/platformos-check-common';
+import { AbstractFileSystem, DocumentsLocator } from '@platformos/platformos-common';
+import { URI } from 'vscode-uri';
+import {
+  PropertyShape,
+  inferShapeFromJSONString,
+  inferShapeFromGraphQL,
+} from './PropertyShapeInference';
+
+export interface VariableShapeEntry {
+  name: string;
+  shape: PropertyShape;
+  range: [start: number, end?: number];
+}
+
+/**
+ * Extract variable shapes from JSON literals, parse_json, and graphql tags in the AST
+ */
+export async function extractVariableShapes(
+  ast: LiquidHtmlNode,
+  fs?: AbstractFileSystem,
+  documentsLocator?: DocumentsLocator,
+  rootUri?: string,
+  graphqlSchema?: string,
+): Promise<VariableShapeEntry[]> {
+  const shapes: VariableShapeEntry[] = [];
+
+  // Helper to close previous shape ranges when a variable is reassigned
+  const closeShapeRange = (variableName: string, endPosition: number) => {
+    for (let i = shapes.length - 1; i >= 0; i--) {
+      if (shapes[i].name === variableName && shapes[i].range[1] === undefined) {
+        shapes[i].range[1] = endPosition;
+        break;
+      }
+    }
+  };
+
+  await visit<SourceCodeType.LiquidHtml, void>(ast, {
+    async LiquidTag(node: LiquidTag) {
+      // {% assign x = '[{"a": 3}]' | parse_json %}
+      // {% assign x = var | default: '{"fallback": true}' | parse_json %}
+      if (isLiquidTagAssign(node)) {
+        const markup = node.markup;
+
+        // Close any previous shape for this variable (reassignment)
+        // Use node.position.end so RHS can still reference old value (e.g., a = a.b)
+        closeShapeRange(markup.name, node.position.end);
+
+        const hasParseJsonFilter =
+          markup.value.filters &&
+          markup.value.filters.some(
+            (f: { name: string }) => f.name === 'parse_json' || f.name === 'to_hash',
+          );
+
+        if (hasParseJsonFilter) {
+          let jsonString: string | undefined;
+
+          // Check if expression is a direct JSON string
+          if (markup.value.expression.type === NodeTypes.String) {
+            jsonString = markup.value.expression.value;
+          }
+
+          // Check if there's a default filter with a JSON string argument
+          if (!jsonString && markup.value.filters) {
+            const defaultFilter = markup.value.filters.find(
+              (f: { name: string }) => f.name === 'default',
+            );
+            if (defaultFilter && defaultFilter.args && defaultFilter.args.length > 0) {
+              const firstArg = defaultFilter.args[0];
+              if (firstArg.type === NodeTypes.String) {
+                jsonString = firstArg.value;
+              }
+            }
+          }
+
+          if (jsonString) {
+            const shape = inferShapeFromJSONString(jsonString);
+            if (shape) {
+              shapes.push({
+                name: markup.name,
+                shape,
+                range: [node.position.end],
+              });
+            }
+          }
+        }
+      }
+
+      // {% parse_json x %}{"a": 5}{% endparse_json %}
+      if (isLiquidTagParseJson(node)) {
+        const variableName = node.markup.name;
+        if (variableName && node.children) {
+          // Close any previous shape for this variable (reassignment)
+          closeShapeRange(variableName, node.position.end);
+
+          const textContent = node.children
+            .filter((c): c is TextNode => c.type === NodeTypes.TextNode)
+            .map((c) => c.value)
+            .join('');
+          const shape = inferShapeFromJSONString(textContent);
+          if (shape) {
+            shapes.push({
+              name: variableName,
+              shape,
+              range: [node.blockEndPosition?.end ?? node.position.end],
+            });
+          }
+        }
+      }
+
+      // {% graphql result %}...inline graphql...{% endgraphql %} (inline)
+      if (isLiquidTagGraphQL(node) && isGraphQLInlineMarkup(node.markup)) {
+        const markup = node.markup;
+        // Close any previous shape for this variable (reassignment)
+        closeShapeRange(markup.name, node.position.end);
+
+        if (node.children) {
+          const textContent = node.children
+            .filter((c): c is TextNode => c.type === NodeTypes.TextNode)
+            .map((c) => c.value)
+            .join('');
+          const shape = inferShapeFromGraphQL(textContent, graphqlSchema);
+          if (shape) {
+            shapes.push({
+              name: markup.name,
+              shape,
+              range: [node.blockEndPosition?.end ?? node.position.end],
+            });
+          }
+        }
+      }
+
+      // {% graphql result = 'file' %} (file-based)
+      if (isLiquidTagGraphQL(node) && isGraphQLFileMarkup(node.markup)) {
+        const markup = node.markup;
+        // Close any previous shape for this variable (reassignment)
+        closeShapeRange(markup.name, node.position.end);
+
+        if (fs && documentsLocator && rootUri && isLiquidString(markup.graphql)) {
+          const graphqlFile = markup.graphql.value;
+          try {
+            const located = await documentsLocator.locate(
+              URI.parse(rootUri),
+              'graphql',
+              graphqlFile,
+            );
+            if (located) {
+              const content = await fs.readFile(located);
+              const shape = inferShapeFromGraphQL(content, graphqlSchema);
+              if (shape) {
+                shapes.push({
+                  name: markup.name,
+                  shape,
+                  range: [node.position.end],
+                });
+              }
+            }
+          } catch {
+            // File read error - skip
+          }
+        }
+      }
+
+      // {% hash_assign x["key"] = value %} or {% hash_assign x["a"]["b"] = value %}
+      // Also handles {% hash_assign a = value %} (no lookups, works like assign)
+      if (isLiquidTagHashAssign(node)) {
+        const markup = node.markup;
+        const variableName = markup.target.name;
+        const lookupPath = getHashAssignLookupPath(markup);
+
+        // Determine value shape - check if value is a JSON string with parse_json filter
+        let valueShape: PropertyShape | undefined;
+        if (markup.value.expression.type === NodeTypes.String) {
+          const hasParseJsonFilter = markup.value.filters.some(
+            (f) => f.name === 'parse_json' || f.name === 'to_hash',
+          );
+          if (hasParseJsonFilter) {
+            valueShape = inferShapeFromJSONString(markup.value.expression.value) ?? undefined;
+          }
+        }
+
+        if (variableName && lookupPath && lookupPath.length > 0) {
+          // Nested property assignment: {% hash_assign a['key'] = value %}
+          const existingIdx = findLastApplicableShapeIndex(
+            variableName,
+            node.position.start,
+            shapes,
+          );
+
+          if (existingIdx !== -1) {
+            const existing = shapes[existingIdx];
+            const newShape = mergeNestedPropertyIntoShape(
+              existing.shape,
+              lookupPath,
+              valueShape ?? { kind: 'primitive' },
+            );
+            shapes.push({
+              name: variableName,
+              shape: newShape,
+              range: [node.position.end],
+            });
+          } else {
+            const newShape = mergeNestedPropertyIntoShape(
+              { kind: 'object', properties: new Map() },
+              lookupPath,
+              valueShape ?? { kind: 'primitive' },
+            );
+            shapes.push({
+              name: variableName,
+              shape: newShape,
+              range: [node.position.end],
+            });
+          }
+        } else if (variableName) {
+          // Direct assignment: {% hash_assign a = value %} (works like assign)
+          // Close any previous shape for this variable (reassignment)
+          closeShapeRange(variableName, node.position.end);
+
+          if (valueShape) {
+            shapes.push({
+              name: variableName,
+              shape: valueShape,
+              range: [node.position.end],
+            });
+          }
+        }
+      }
+    },
+  });
+
+  return shapes;
+}
+
+export function findLastApplicableShapeIndex(
+  variableName: string,
+  position: number,
+  shapes: VariableShapeEntry[],
+): number {
+  let lastIdx = -1;
+
+  for (let i = 0; i < shapes.length; i++) {
+    const shape = shapes[i];
+    if (shape.name !== variableName) continue;
+    const [start, end] = shape.range;
+    if (position <= start) continue;
+    if (end && position > end) continue;
+    lastIdx = i;
+  }
+
+  return lastIdx;
+}
+
+export function buildLookupPath(
+  lookups: LiquidExpression[],
+  cursor?: string,
+): string[] | undefined {
+  const path: string[] = [];
+
+  for (const lookup of lookups) {
+    if (lookup.type === NodeTypes.String) {
+      path.push(cursor ? lookup.value.replace(cursor, '') : lookup.value);
+    } else if (lookup.type === NodeTypes.Number) {
+      path.push(String(lookup.value));
+    } else {
+      return undefined;
+    }
+  }
+
+  return path;
+}
+
+/**
+ * Extract the lookup path from a hash_assign target.
+ * For {% hash_assign a['key1']['key2'] = value %}, returns ['key1', 'key2']
+ */
+function getHashAssignLookupPath(markup: HashAssignMarkup): string[] | undefined {
+  const path: string[] = [];
+
+  for (const lookup of markup.target.lookups) {
+    if (lookup.type === NodeTypes.String) {
+      path.push(lookup.value);
+    } else if (lookup.type === NodeTypes.Number) {
+      path.push(String(lookup.value));
+    } else {
+      // Dynamic lookup - can't determine statically
+      return undefined;
+    }
+  }
+
+  return path.length > 0 ? path : undefined;
+}
+
+/**
+ * Merge a nested property into a shape following a path.
+ * For path ['a', 'b'] and valueShape, creates/updates shape.a.b = valueShape
+ */
+function mergeNestedPropertyIntoShape(
+  shape: PropertyShape,
+  path: string[],
+  valueShape: PropertyShape,
+): PropertyShape {
+  if (path.length === 0) {
+    return valueShape;
+  }
+
+  const [key, ...rest] = path;
+
+  if (shape.kind !== 'object') {
+    // Convert to object
+    const properties = new Map<string, PropertyShape>();
+    if (rest.length === 0) {
+      properties.set(key, valueShape);
+    } else {
+      properties.set(
+        key,
+        mergeNestedPropertyIntoShape({ kind: 'object', properties: new Map() }, rest, valueShape),
+      );
+    }
+    return { kind: 'object', properties };
+  }
+
+  const newProperties = new Map(shape.properties);
+  if (rest.length === 0) {
+    newProperties.set(key, valueShape);
+  } else {
+    const existingNested = newProperties.get(key) || { kind: 'object', properties: new Map() };
+    newProperties.set(key, mergeNestedPropertyIntoShape(existingNested, rest, valueShape));
+  }
+  return { kind: 'object', properties: newProperties };
+}
+
+// Type guards
+function isLiquidTagAssign(
+  node: LiquidTag,
+): node is LiquidTag & { markup: { name: string; value: { filters: any[]; expression: any } } } {
+  return node.name === NamedTags.assign && typeof node.markup !== 'string';
+}
+
+function isLiquidTagParseJson(
+  node: LiquidTag,
+): node is LiquidTag & { markup: LiquidVariableLookup; children: LiquidHtmlNode[] } {
+  return node.name === NamedTags.parse_json && typeof node.markup !== 'string';
+}
+
+function isLiquidTagGraphQL(
+  node: LiquidTag,
+): node is LiquidTag & { markup: GraphQLMarkup | GraphQLInlineMarkup } {
+  return node.name === NamedTags.graphql && typeof node.markup !== 'string';
+}
+
+function isLiquidTagHashAssign(node: LiquidTag): node is LiquidTag & { markup: HashAssignMarkup } {
+  return node.name === NamedTags.hash_assign && typeof node.markup !== 'string';
+}
+
+function isGraphQLInlineMarkup(
+  markup: GraphQLMarkup | GraphQLInlineMarkup,
+): markup is GraphQLInlineMarkup {
+  return markup.type === NodeTypes.GraphQLInlineMarkup;
+}
+
+function isGraphQLFileMarkup(markup: GraphQLMarkup | GraphQLInlineMarkup): markup is GraphQLMarkup {
+  return markup.type === NodeTypes.GraphQLMarkup;
+}
+
+function isLiquidString(node: LiquidString | LiquidVariableLookup): node is LiquidString {
+  return node.type === NodeTypes.String;
+}

package/src/codeActions/BaseCodeActionsProvider.ts

@@ -0,0 +1,18 @@
+import { CodeAction, CodeActionKind, CodeActionParams, Command } from 'vscode-languageserver';
+import { DiagnosticsManager } from '../diagnostics';
+import { DocumentManager } from '../documents';
+
+export abstract class BaseCodeActionsProvider {
+  static kind: CodeActionKind;
+
+  constructor(
+    protected documentManager: DocumentManager,
+    protected diagnosticsManager: DiagnosticsManager,
+  ) {}
+
+  get kind() {
+    return (this.constructor as typeof BaseCodeActionsProvider).kind;
+  }
+
+  abstract codeActions(params: CodeActionParams): (Command | CodeAction)[];
+}

package/src/codeActions/CodeActionsProvider.ts

@@ -0,0 +1,28 @@
+import { CodeAction, CodeActionParams, Command } from 'vscode-languageserver';
+import { DiagnosticsManager } from '../diagnostics';
+import { DocumentManager } from '../documents';
+import { FixAllProvider, FixProvider, SuggestionProvider } from './providers';
+import { BaseCodeActionsProvider } from './BaseCodeActionsProvider';
+
+export const CodeActionKinds = Array.from(
+  new Set([FixAllProvider.kind, FixProvider.kind, SuggestionProvider.kind]),
+);
+
+export class CodeActionsProvider {
+  private providers: BaseCodeActionsProvider[];
+
+  constructor(documentManager: DocumentManager, diagnosticsManager: DiagnosticsManager) {
+    this.providers = [
+      new FixAllProvider(documentManager, diagnosticsManager),
+      new FixProvider(documentManager, diagnosticsManager),
+      new SuggestionProvider(documentManager, diagnosticsManager),
+    ];
+  }
+
+  codeActions(params: CodeActionParams): (Command | CodeAction)[] {
+    const only = params.context.only;
+    return this.providers
+      .filter((provider) => !only || only.some((kind) => provider.kind.startsWith(kind)))
+      .flatMap((provider) => provider.codeActions(params));
+  }
+}

package/src/codeActions/index.ts

@@ -0,0 +1 @@
+export { CodeActionsProvider, CodeActionKinds } from './CodeActionsProvider';

package/src/codeActions/providers/FixAllProvider.spec.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { URI } from 'vscode-uri';
+import { Offense, SourceCodeType, Severity, path } from '@platformos/platformos-check-common';
+import { DiagnosticsManager } from '../../diagnostics';
+import { DocumentManager } from '../../documents';
+import { FixAllProvider } from './FixAllProvider';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+
+describe('Unit: FixAllProvider', () => {
+  const uri = path.normalize(URI.file('/path/to/file.liquid'));
+  const contents = `
+    {% assign x = 1 %}
+    <script src="2.js"></script>
+    <script src="3.js"></script>
+  `;
+  const version = 0;
+  const document = TextDocument.create(uri, 'liquid', version, contents);
+  let documentManager: DocumentManager;
+  let diagnosticsManager: DiagnosticsManager;
+  let fixProvider: FixAllProvider;
+
+  function makeOffense(
+    checkName: string,
+    needle: string,
+    unfixable?: boolean,
+  ): Offense<SourceCodeType.LiquidHtml> {
+    const start = contents.indexOf(needle);
+    const end = start + needle.length;
+
+    return {
+      type: SourceCodeType.LiquidHtml,
+      check: checkName,
+      message: 'Parser blocking script detected',
+      uri: 'file:///path/to/file.liquid',
+      severity: Severity.ERROR,
+      start: { ...document.positionAt(start), index: start },
+      end: { ...document.positionAt(end), index: end },
+      fix: unfixable ? undefined : (corrector) => corrector.replace(18, 36, 'fixed'),
+    };
+  }
+
+  beforeEach(() => {
+    documentManager = new DocumentManager();
+    diagnosticsManager = new DiagnosticsManager({ sendDiagnostics: vi.fn() } as any);
+    documentManager.open(uri, contents, version);
+    fixProvider = new FixAllProvider(documentManager, diagnosticsManager);
+  });
+
+  it('provides a code action to solve all fixable problems', async () => {
+    diagnosticsManager.set(uri, version, [
+      makeOffense('UnusedAssign', '{% assign x = 1 %}'),
+      makeOffense('ParserBlockingScript', '<script src="2.js"></script>'),
+      makeOffense('ParserBlockingScript', '<script src="3.js"></script>'),
+    ]);
+
+    const codeActions = fixProvider.codeActions({
+      textDocument: { uri },
+      range: {
+        start: document.positionAt(contents.indexOf('2.js')),
+        end: document.positionAt(contents.indexOf('2.js')),
+      },
+      context: { diagnostics: [] },
+    });
+
+    expect(codeActions.length).toBe(1);
+
+    const [fixAllAction] = codeActions;
+
+    expect(fixAllAction).toEqual({
+      title: 'Fix all auto-fixable problems',
+      kind: 'source.fixAll',
+      diagnostics: expect.any(Array),
+      isPreferred: false,
+      command: {
+        title: 'applyFixes',
+        command: 'themeCheck/applyFixes',
+        arguments: [uri, version, [0, 1, 2]],
+      },
+    });
+  });
+
+  it('does not provide code actions for non-fixable offenses', async () => {
+    const nonFixableOffense = makeOffense('ParserBlockingScript', '<script src="2.js">', true);
+    diagnosticsManager.set(uri, version, [nonFixableOffense]);
+
+    const codeActions = fixProvider.codeActions({
+      textDocument: { uri },
+      range: {
+        start: document.positionAt(contents.indexOf('2.js')),
+        end: document.positionAt(contents.indexOf('2.js')),
+      },
+      context: { diagnostics: [] },
+    });
+
+    expect(codeActions.length).toBe(0);
+  });
+
+  it('does provide code action if the selection range does not overlap with the error', async () => {
+    diagnosticsManager.set(uri, version, [
+      makeOffense('ParserBlockingScript', '<script src="2.js"></script>'),
+      makeOffense('ParserBlockingScript', '<script src="3.js"></script>'),
+    ]);
+
+    const codeActions = fixProvider.codeActions({
+      textDocument: { uri },
+      range: {
+        start: document.positionAt(contents.indexOf('assign x = 1')),
+        end: document.positionAt(contents.indexOf('= 1')),
+      },
+      context: { diagnostics: [] },
+    });
+
+    expect(codeActions.length).toBe(1);
+  });
+});

package/src/codeActions/providers/FixAllProvider.ts

@@ -0,0 +1,60 @@
+import { CodeAction, CodeActionKind, CodeActionParams, Command } from 'vscode-languageserver';
+import { applyFixCommand } from '../../commands';
+import { BaseCodeActionsProvider } from '../BaseCodeActionsProvider';
+import { FixableAnomaly, isFixable, toCodeAction } from './utils';
+
+/**
+ * FixAllProvider is a `source.fixAll` code action provider.
+ *
+ * It is different from FixProvider in the sense where this won't appear on
+ * top of diagnostics, but rather can be executed in different contexts.
+ * Unlike FixProvider, it is also cursor position independent.
+ *
+ * Folks can have this run automatically on save with the following config:
+ *
+ * "[liquid]": {
+ *   "editor.codeActionsOnSave": {
+ *     "source.fixAll": true,
+ *   }
+ * },
+ *
+ * Or as as 'Right click > Source Actions...' request
+ */
+export class FixAllProvider extends BaseCodeActionsProvider {
+  static kind = CodeActionKind.SourceFixAll;
+
+  codeActions(params: CodeActionParams): (Command | CodeAction)[] {
+    const { uri } = params.textDocument;
+    const document = this.documentManager.get(uri);
+    const diagnostics = this.diagnosticsManager.get(uri);
+    if (!document || !diagnostics) return [];
+
+    const { anomalies, version } = diagnostics;
+    const fixableAnomalies = anomalies.filter(isFixable);
+    if (fixableAnomalies.length === 0) return [];
+
+    return quickfixAllAction(uri, version, fixableAnomalies);
+  }
+}
+
+/**
+ * @returns code action to fix all offenses in a file
+ * @example Fix all auto-fixable problems
+ */
+function quickfixAllAction(
+  uri: string,
+  version: number | undefined,
+  fixableAnomalies: FixableAnomaly[],
+): CodeAction[] {
+  const ids = fixableAnomalies.map((a) => a.id);
+  const diagnostics = fixableAnomalies.map((a) => a.diagnostic);
+
+  return [
+    toCodeAction(
+      `Fix all auto-fixable problems`,
+      applyFixCommand(uri, version, ids),
+      diagnostics,
+      FixAllProvider.kind,
+    ),
+  ];
+}