@px-lsp/server 0.1.0

package/src/serverData.ts

@@ -0,0 +1,98 @@
+/**
+ * Shared mutable state for the language server: parsed script_docs tokens and
+ * the definition index, plus a plain change-listener list so features can
+ * invalidate caches. The vscode EventEmitter of the old in-process design is
+ * replaced by a minimal callback registry (no vscode imports server-side).
+ */
+import type { TokenData } from "@px-lsp/protocol/types";
+import { compileModifierTemplates, type ModifierTemplate } from "./data/modifierTemplates";
+import { emptyDataTypes, type DataTypesData } from "./data/dataTypes";
+import { emptyUsage, type DataFnUsage } from "./data/dataFnUsage";
+import { DefinesIndex } from "./data/defines";
+import { TextFormattingIndex } from "./data/textFormatting";
+import { DefinitionIndex } from "./index/indexer";
+import { ReferenceIndex } from "./index/references";
+import { ScopeModel } from "./scopes/model";
+
+export class ServerData {
+  tokens: TokenData[] = [];
+  /** name -> all tokens with that name (a name can be both trigger and effect). */
+  tokenMap = new Map<string, TokenData[]>();
+  /** Templated modifier tags ($CULTURE$_opinion), compiled for lazy expansion. */
+  modifierTemplates: ModifierTemplate[] = [];
+  /** [ ... ] datafunction tables (bundled wiki baseline / user's DumpDataTypes output). */
+  dataTypes: DataTypesData = emptyDataTypes();
+  /** Vanilla [ ... ] usage harvest: counts, literals, examples (dataFnUsage.ts). */
+  dataFnUsage: DataFnUsage = emptyUsage();
+  /** `define:NS|CONST` constants harvested from engine/game/mod defines. */
+  defines = new DefinesIndex();
+  /** `#tag` loc text-formatting definitions harvested from gui textformatting blocks. */
+  textFormatting = new TextFormattingIndex();
+  index = new DefinitionIndex();
+  /** Usage sites, mod files only (vanilla references are computed on demand). */
+  refIndex = new ReferenceIndex();
+  /** Event namespaces declared by mod files (for conservative unknown-event checks). */
+  modNamespaces = new Set<string>();
+  /** Definition kinds that appear in completion lists (from the schema). */
+  completableKinds = new Set<string>();
+  /** Scope link table derived from the token data (AD-5); rebuilt with tokens. */
+  scopeModel = new ScopeModel([]);
+  /** on_action name → expected root scope, parsed from the user's on_actions.log. */
+  onActionScopes = new Map<string, string>();
+  /** Schema root scopes for an absolute file path (set by the host; used for
+   *  static variable-type resolution — see scopes/varTypes.ts). */
+  rootScopesForFile: (file: string) => Set<string> | null = () => null;
+  /** Origin label for a definition: the owning mod's descriptor name instead of
+   *  the generic "mod"/"parent" (set by the host from the configured roots —
+   *  see index/modOrigin.ts). Default: the raw source tag. */
+  originLabel: (def: { file: string; source: string }) => string = (def) => def.source;
+  /** The mod root a file lives under (set by the host; used to scope the
+   *  overview views to one workspace mod). Default: unknown. */
+  modRootOf: (file: string) => string | null = () => null;
+
+  private listeners: Array<() => void> = [];
+
+  onDidChange(listener: () => void): void {
+    this.listeners.push(listener);
+  }
+
+  setTokens(tokens: TokenData[]): void {
+    this.tokens = tokens;
+    this.tokenMap.clear();
+    for (const t of tokens) {
+      const list = this.tokenMap.get(t.name);
+      if (list) list.push(t);
+      else this.tokenMap.set(t.name, [t]);
+    }
+    this.scopeModel = new ScopeModel(tokens);
+    this.applyScriptedLists();
+    this.fire();
+  }
+
+  setModifierTemplates(raw: TokenData[]): void {
+    this.modifierTemplates = compileModifierTemplates(raw);
+    this.fire();
+  }
+
+  notifyIndexChanged(): void {
+    this.applyScriptedLists();
+    this.fire();
+  }
+
+  /** Feed scripted-list definitions (name + base) into the scope model so their
+   *  generated every_/any_/random_/ordered_ iterators resolve target scopes. */
+  private applyScriptedLists(): void {
+    const lists: Array<{ name: string; base?: string }> = [];
+    // index.scriptedLists() is the incremental form of
+    // entries(d => d.kind === "scripted_list") — same result, without the
+    // full-name walk this used to pay on every index change (§B2).
+    for (const d of this.index.scriptedLists()) {
+      lists.push({ name: d.name, base: d.value });
+    }
+    this.scopeModel.setScriptedLists(lists);
+  }
+
+  private fire(): void {
+    for (const l of this.listeners) l();
+  }
+}

package/src/structure.ts

@@ -0,0 +1,56 @@
+/**
+ * Block-schema structure context (update plan v1.1 §B2): which named sub-block
+ * of a definition kind the cursor sits in, and the KeySpecs valid there.
+ *
+ * Pairs the file's schema kind (from classifyFile) with the CST block stack:
+ * the innermost stack keyword that names a structure sub-block wins; otherwise
+ * the cursor is at the definition's top level. Transparent wrappers (first_valid,
+ * random_list, if…) are simply not named blocks, so the walk skips past them.
+ *
+ * No `vscode` imports: unit-tested in plain Node.
+ */
+import type { KeySpec } from "./schema/types";
+import type { StructureIndex } from "./schema/loader";
+import { blockStackFromParse } from "./context";
+import type { ParseResult } from "./parser";
+
+export interface StructureContext {
+  /** Schema kind of the file, e.g. "character_interaction". */
+  kind: string;
+  /** Named sub-block the cursor is in, or "" for the definition's top level. */
+  block: string;
+  /** KeySpecs valid at this position (empty if the kind/block is unknown). */
+  keys: Map<string, KeySpec>;
+}
+
+/**
+ * Resolve the structure context at `offset`. Returns null when the file's kind
+ * has no `structure` layer (most kinds) — callers then skip structure work.
+ */
+export function structureContextAt(
+  parse: ParseResult,
+  offset: number,
+  kind: string,
+  structures: StructureIndex
+): StructureContext | null {
+  const byBlock = structures.keysByKindBlock.get(kind);
+  if (!byBlock) return null;
+
+  const stack = blockStackFromParse(parse, offset);
+  // The outermost named frame is the definition body; its top-level keys apply
+  // only when the cursor sits DIRECTLY in it. A recognized sub-block (option,
+  // send_option…) supplies its own keys. Any other named block between the
+  // definition body and the cursor (immediate, trigger, limit, a scope change…)
+  // is a trigger/effect/transparent block, not a structural level — return null so
+  // completion offers tokens there instead of leaking top-level structure keys.
+  const named = stack.filter((s) => s !== "<anon>");
+  if (named.length === 0) return null; // above/outside any definition body
+  const innermost = named[named.length - 1].toLowerCase();
+  if (named.length === 1) {
+    // Directly in the definition body → top-level keys.
+    return { kind, block: "", keys: byBlock.get("") ?? new Map<string, KeySpec>() };
+  }
+  const sub = byBlock.get(innermost);
+  if (sub) return { kind, block: innermost, keys: sub };
+  return null;
+}

package/src/wordAt.ts

@@ -0,0 +1,49 @@
+/**
+ * Word extraction matching the language-configuration wordPattern
+ * (`[A-Za-z0-9_][A-Za-z0-9_.\-]*`), so server-side lookups see the same words
+ * the editor selects. No `vscode` imports.
+ */
+
+const WORD = /[A-Za-z0-9_][A-Za-z0-9_.-]*/g;
+
+export interface WordRange {
+  word: string;
+  /** Character offsets on the line. */
+  start: number;
+  end: number;
+}
+
+/** The word at `character` on `lineText`, VS Code-style (position may touch either edge). */
+export function wordRangeAt(lineText: string, character: number): WordRange | null {
+  WORD.lastIndex = 0;
+  let m: RegExpExecArray | null;
+  while ((m = WORD.exec(lineText)) !== null) {
+    const start = m.index;
+    const end = start + m[0].length;
+    if (character >= start && character <= end) return { word: m[0], start, end };
+    if (start > character) break;
+  }
+  return null;
+}
+
+/** Prefixes that make the following word a saved-scope / variable reference. */
+const SCOPE_PREFIXES = ["scope", "var", "local_var", "global_var"];
+
+/**
+ * If the word at `range` is immediately preceded by a `scope:` / `var:` (etc.)
+ * prefix on the line, return that prefix; otherwise null. The wordPattern splits
+ * at `:`, so hover would otherwise look up the bare name and lose the prefix
+ * (update plan v1.1 §B3 hover work).
+ */
+export function scopePrefixBefore(lineText: string, range: WordRange): string | null {
+  if (range.start === 0 || lineText[range.start - 1] !== ":") return null;
+  const before = lineText.slice(0, range.start - 1);
+  for (const p of SCOPE_PREFIXES) {
+    if (before.endsWith(p)) {
+      // Make sure the prefix is a whole token (not the tail of a longer word).
+      const at = before.length - p.length;
+      if (at === 0 || !/[A-Za-z0-9_.-]/.test(before[at - 1])) return p;
+    }
+  }
+  return null;
+}