mrmd-js 2.0.0

package/src/lsp/complete.js

@@ -0,0 +1,353 @@
+/**
+ * Code Completion
+ *
+ * Provides runtime-aware code completions by introspecting live values
+ * in the execution context.
+ *
+ * @module lsp/complete
+ */
+
+import {
+  parseCompletionContext,
+  splitObjectPath,
+  isKeyword,
+  getKeywords,
+  getCommonGlobals,
+} from './parse.js';
+
+import {
+  formatValueShort,
+  getTypeName,
+  getCompletionKind,
+  getFunctionSignature,
+} from './format.js';
+
+/**
+ * @typedef {import('../session/context/interface.js').ExecutionContext} ExecutionContext
+ * @typedef {import('../types/completion.js').CompletionResult} CompletionResult
+ * @typedef {import('../types/completion.js').CompletionItem} CompletionItem
+ * @typedef {import('../types/completion.js').CompleteOptions} CompleteOptions
+ */
+
+/**
+ * Get completions at cursor position
+ *
+ * @param {string} code - The code being edited
+ * @param {number} cursor - Cursor position (0-indexed)
+ * @param {ExecutionContext} context - Execution context for live values
+ * @param {CompleteOptions} [options]
+ * @returns {CompletionResult}
+ */
+export function getCompletions(code, cursor, context, options = {}) {
+  const ctx = parseCompletionContext(code, cursor);
+
+  // Don't complete inside strings or comments
+  if (ctx.type === 'string' || ctx.type === 'comment') {
+    return {
+      matches: [],
+      cursorStart: cursor,
+      cursorEnd: cursor,
+      source: 'runtime',
+    };
+  }
+
+  /** @type {CompletionItem[]} */
+  let matches = [];
+
+  switch (ctx.type) {
+    case 'member':
+      matches = getMemberCompletions(ctx.object || '', ctx.prefix, context);
+      break;
+
+    case 'bracket':
+      matches = getBracketCompletions(ctx.object || '', context);
+      break;
+
+    case 'global':
+    default:
+      matches = getGlobalCompletions(ctx.prefix, context);
+      break;
+  }
+
+  // Filter by prefix
+  if (ctx.prefix) {
+    const lowerPrefix = ctx.prefix.toLowerCase();
+    matches = matches.filter(item =>
+      item.label.toLowerCase().startsWith(lowerPrefix)
+    );
+  }
+
+  // Sort by priority and name
+  matches.sort((a, b) => {
+    const priorityDiff = (a.sortPriority ?? 50) - (b.sortPriority ?? 50);
+    if (priorityDiff !== 0) return priorityDiff;
+    return a.label.localeCompare(b.label);
+  });
+
+  return {
+    matches,
+    cursorStart: ctx.start,
+    cursorEnd: ctx.end,
+    source: 'runtime',
+  };
+}
+
+/**
+ * Get completions for member access (dot notation)
+ * @param {string} objectPath
+ * @param {string} prefix
+ * @param {ExecutionContext} context
+ * @returns {CompletionItem[]}
+ */
+function getMemberCompletions(objectPath, prefix, context) {
+  if (!objectPath) return [];
+
+  // Resolve the object in context
+  const value = resolveValue(objectPath, context);
+  if (value === undefined && !objectPath.includes('.')) {
+    // Check if it's a global
+    const global = context.getGlobal();
+    if (global && objectPath in global) {
+      // @ts-ignore
+      return getPropertiesOf(global[objectPath]);
+    }
+  }
+
+  if (value === undefined || value === null) {
+    return [];
+  }
+
+  return getPropertiesOf(value);
+}
+
+/**
+ * Get completions for bracket access
+ * @param {string} objectPath
+ * @param {ExecutionContext} context
+ * @returns {CompletionItem[]}
+ */
+function getBracketCompletions(objectPath, context) {
+  const value = resolveValue(objectPath, context);
+
+  if (Array.isArray(value)) {
+    // Suggest indices
+    return value.slice(0, 20).map((_, i) => ({
+      label: String(i),
+      kind: /** @type {const} */ ('value'),
+      detail: getTypeName(value[i]),
+      valuePreview: formatValueShort(value[i]),
+      sortPriority: 10,
+    }));
+  }
+
+  if (value instanceof Map) {
+    // Suggest keys
+    return Array.from(value.keys()).slice(0, 20).map(key => ({
+      label: String(key),
+      insertText: typeof key === 'string' ? `"${key}"` : String(key),
+      kind: /** @type {const} */ ('property'),
+      detail: getTypeName(value.get(key)),
+      valuePreview: formatValueShort(value.get(key)),
+      sortPriority: 10,
+    }));
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    // Suggest string keys
+    return Object.keys(value).slice(0, 50).map(key => ({
+      label: key,
+      insertText: `"${key}"`,
+      kind: /** @type {const} */ ('property'),
+      detail: getTypeName(value[key]),
+      valuePreview: formatValueShort(value[key]),
+      sortPriority: 10,
+    }));
+  }
+
+  return [];
+}
+
+/**
+ * Get completions for global context
+ * @param {string} prefix
+ * @param {ExecutionContext} context
+ * @returns {CompletionItem[]}
+ */
+function getGlobalCompletions(prefix, context) {
+  /** @type {CompletionItem[]} */
+  const items = [];
+
+  // 1. User-defined variables (highest priority)
+  const userVars = context.getVariables();
+  for (const [name, value] of Object.entries(userVars)) {
+    items.push({
+      label: name,
+      kind: getCompletionKind(value),
+      detail: getTypeName(value),
+      valuePreview: formatValueShort(value),
+      type: getTypeName(value),
+      sortPriority: 10,
+    });
+  }
+
+  // 2. Keywords
+  for (const keyword of getKeywords()) {
+    items.push({
+      label: keyword,
+      kind: 'keyword',
+      sortPriority: 60,
+    });
+  }
+
+  // 3. Common globals
+  const global = context.getGlobal();
+  for (const name of getCommonGlobals()) {
+    if (name in userVars) continue; // Skip if user defined
+
+    try {
+      // @ts-ignore
+      const value = global?.[name];
+      if (value !== undefined) {
+        items.push({
+          label: name,
+          kind: getCompletionKind(value),
+          detail: getTypeName(value),
+          type: getTypeName(value),
+          sortPriority: 40,
+        });
+      }
+    } catch {
+      // Skip inaccessible
+    }
+  }
+
+  // 4. Add some built-in globals that might be useful
+  const builtinGlobals = ['globalThis', 'window', 'document', 'navigator', 'location'];
+  for (const name of builtinGlobals) {
+    if (name in userVars) continue;
+    try {
+      // @ts-ignore
+      const value = global?.[name];
+      if (value !== undefined) {
+        items.push({
+          label: name,
+          kind: 'variable',
+          detail: getTypeName(value),
+          sortPriority: 50,
+        });
+      }
+    } catch {
+      // Skip inaccessible
+    }
+  }
+
+  return items;
+}
+
+/**
+ * Get all properties of an object as completion items
+ * @param {*} value
+ * @returns {CompletionItem[]}
+ */
+function getPropertiesOf(value) {
+  /** @type {CompletionItem[]} */
+  const items = [];
+  const seen = new Set();
+
+  // Walk prototype chain
+  let obj = value;
+  let depth = 0;
+
+  while (obj != null && depth < 5) {
+    const names = Object.getOwnPropertyNames(obj);
+
+    for (const name of names) {
+      if (seen.has(name)) continue;
+      if (name === 'constructor') continue; // Skip constructor
+      seen.add(name);
+
+      try {
+        const descriptor = Object.getOwnPropertyDescriptor(obj, name);
+        const propValue = descriptor?.get ? undefined : value[name];
+
+        /** @type {CompletionItem} */
+        const item = {
+          label: name,
+          kind: typeof propValue === 'function' ? 'method' : 'property',
+          sortPriority: depth === 0 ? 20 : 30 + depth,
+        };
+
+        if (propValue !== undefined) {
+          item.detail = getTypeName(propValue);
+          item.type = getTypeName(propValue);
+
+          if (typeof propValue === 'function') {
+            item.detail = getFunctionSignature(propValue);
+          } else {
+            item.valuePreview = formatValueShort(propValue);
+          }
+        } else if (descriptor?.get) {
+          item.detail = '(getter)';
+        }
+
+        items.push(item);
+      } catch {
+        // Skip inaccessible properties
+        items.push({
+          label: name,
+          kind: 'property',
+          detail: '(inaccessible)',
+          sortPriority: 90,
+        });
+      }
+    }
+
+    obj = Object.getPrototypeOf(obj);
+    depth++;
+  }
+
+  return items;
+}
+
+/**
+ * Resolve a value from an object path in the context
+ * @param {string} path
+ * @param {ExecutionContext} context
+ * @returns {*}
+ */
+function resolveValue(path, context) {
+  const parts = splitObjectPath(path);
+  if (parts.length === 0) return undefined;
+
+  // Start with user variables or global
+  let value = context.getVariable(parts[0]);
+
+  if (value === undefined) {
+    // Try global
+    const global = context.getGlobal();
+    if (global && parts[0] in global) {
+      // @ts-ignore
+      value = global[parts[0]];
+    }
+  }
+
+  if (value === undefined) return undefined;
+
+  // Navigate path
+  for (let i = 1; i < parts.length; i++) {
+    if (value === null || value === undefined) return undefined;
+
+    try {
+      if (value instanceof Map) {
+        value = value.get(parts[i]);
+      } else {
+        // @ts-ignore
+        value = value[parts[i]];
+      }
+    } catch {
+      return undefined;
+    }
+  }
+
+  return value;
+}

package/src/lsp/format.js

@@ -0,0 +1,310 @@
+/**
+ * Value Formatting Utilities
+ *
+ * Utilities for formatting JavaScript values for display in
+ * completions, hover, and variable inspection.
+ *
+ * @module lsp/format
+ */
+
+/**
+ * Format a value for display as a string
+ * @param {*} value
+ * @param {number} [maxLength=1000]
+ * @returns {string | undefined}
+ */
+export function formatValue(value, maxLength = 1000) {
+  if (value === undefined) return undefined;
+  if (value === null) return 'null';
+
+  if (typeof value === 'function') {
+    const name = value.name || 'anonymous';
+    return `[Function: ${name}]`;
+  }
+
+  if (typeof value === 'symbol') {
+    return value.toString();
+  }
+
+  if (value instanceof Error) {
+    return `${value.name}: ${value.message}`;
+  }
+
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+
+  if (value instanceof Map) {
+    const preview = Array.from(value.entries())
+      .slice(0, 5)
+      .map(([k, v]) => `${formatValueShort(k)} => ${formatValueShort(v)}`)
+      .join(', ');
+    const more = value.size > 5 ? `, ... (${value.size} total)` : '';
+    return `Map(${value.size}) {${preview}${more}}`;
+  }
+
+  if (value instanceof Set) {
+    const preview = Array.from(value)
+      .slice(0, 5)
+      .map(formatValueShort)
+      .join(', ');
+    const more = value.size > 5 ? `, ... (${value.size} total)` : '';
+    return `Set(${value.size}) {${preview}${more}}`;
+  }
+
+  if (Array.isArray(value)) {
+    const preview = value.slice(0, 5).map(formatValueShort).join(', ');
+    const more = value.length > 5 ? `, ... (${value.length} total)` : '';
+    return `[${preview}${more}]`;
+  }
+
+  if (typeof value === 'object') {
+    try {
+      const json = JSON.stringify(value, null, 2);
+      if (json.length > maxLength) {
+        return json.slice(0, maxLength) + '...';
+      }
+      return json;
+    } catch {
+      return String(value);
+    }
+  }
+
+  const str = String(value);
+  if (str.length > maxLength) {
+    return str.slice(0, maxLength) + '...';
+  }
+  return str;
+}
+
+/**
+ * Format a value for short display (single line, truncated)
+ * @param {*} value
+ * @param {number} [maxLength=50]
+ * @returns {string}
+ */
+export function formatValueShort(value, maxLength = 50) {
+  if (value === undefined) return 'undefined';
+  if (value === null) return 'null';
+
+  if (typeof value === 'string') {
+    const truncated = value.length > maxLength - 2
+      ? value.slice(0, maxLength - 5) + '...'
+      : value;
+    return JSON.stringify(truncated);
+  }
+
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+
+  if (typeof value === 'function') {
+    return `ƒ ${value.name || 'anonymous'}()`;
+  }
+
+  if (typeof value === 'symbol') {
+    return value.toString();
+  }
+
+  if (Array.isArray(value)) {
+    return `Array(${value.length})`;
+  }
+
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+
+  if (value instanceof RegExp) {
+    const str = value.toString();
+    return str.length > maxLength ? str.slice(0, maxLength - 3) + '...' : str;
+  }
+
+  if (value instanceof Map) {
+    return `Map(${value.size})`;
+  }
+
+  if (value instanceof Set) {
+    return `Set(${value.size})`;
+  }
+
+  if (value instanceof Error) {
+    return `${value.name}: ${value.message.slice(0, 30)}`;
+  }
+
+  if (typeof value === 'object') {
+    const constructor = value.constructor?.name;
+    if (constructor && constructor !== 'Object') {
+      return constructor;
+    }
+    const keys = Object.keys(value);
+    return `{${keys.slice(0, 3).join(', ')}${keys.length > 3 ? ', ...' : ''}}`;
+  }
+
+  return String(value).slice(0, maxLength);
+}
+
+/**
+ * Get type name for a value
+ * @param {*} value
+ * @returns {string}
+ */
+export function getTypeName(value) {
+  if (value === null) return 'null';
+  if (value === undefined) return 'undefined';
+  if (Array.isArray(value)) return 'Array';
+  if (value instanceof Date) return 'Date';
+  if (value instanceof RegExp) return 'RegExp';
+  if (value instanceof Error) return value.constructor.name;
+  if (value instanceof Map) return 'Map';
+  if (value instanceof Set) return 'Set';
+  if (value instanceof WeakMap) return 'WeakMap';
+  if (value instanceof WeakSet) return 'WeakSet';
+  if (value instanceof Promise) return 'Promise';
+  if (value instanceof ArrayBuffer) return 'ArrayBuffer';
+
+  // Typed arrays
+  if (ArrayBuffer.isView(value)) {
+    return value.constructor.name;
+  }
+
+  const type = typeof value;
+  if (type === 'object') {
+    const constructor = value.constructor;
+    if (constructor && constructor.name !== 'Object') {
+      return constructor.name;
+    }
+    return 'Object';
+  }
+
+  return type;
+}
+
+/**
+ * Get the kind of a value for completion icons
+ * @param {*} value
+ * @returns {import('../types/completion.js').CompletionKind}
+ */
+export function getCompletionKind(value) {
+  if (value === null || value === undefined) {
+    return 'value';
+  }
+
+  if (typeof value === 'function') {
+    // Check if it's a class (constructor)
+    if (/^class\s/.test(value.toString())) {
+      return 'class';
+    }
+    return 'function';
+  }
+
+  if (typeof value === 'object') {
+    if (Array.isArray(value)) return 'variable';
+    if (value instanceof Map || value instanceof Set) return 'variable';
+    return 'variable';
+  }
+
+  return 'value';
+}
+
+/**
+ * Check if a value is expandable (has children)
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function isExpandable(value) {
+  if (value === null || value === undefined) return false;
+  if (typeof value === 'object') return true;
+  if (typeof value === 'function') return true;
+  return false;
+}
+
+/**
+ * Get function signature from a function
+ * @param {Function} fn
+ * @returns {string}
+ */
+export function getFunctionSignature(fn) {
+  if (typeof fn !== 'function') return '';
+
+  const str = fn.toString();
+
+  // Handle arrow functions
+  if (str.startsWith('(') || /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>/.test(str)) {
+    const match = str.match(/^(\([^)]*\)|[a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/);
+    if (match) {
+      const params = match[1].startsWith('(') ? match[1] : `(${match[1]})`;
+      return `${params} => ...`;
+    }
+  }
+
+  // Handle regular functions
+  const funcMatch = str.match(/^(?:async\s+)?function\s*([^(]*)\(([^)]*)\)/);
+  if (funcMatch) {
+    const name = funcMatch[1].trim() || fn.name || 'anonymous';
+    const params = funcMatch[2];
+    return `function ${name}(${params})`;
+  }
+
+  // Handle method shorthand
+  const methodMatch = str.match(/^(?:async\s+)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(([^)]*)\)/);
+  if (methodMatch) {
+    return `${methodMatch[1]}(${methodMatch[2]})`;
+  }
+
+  // Handle class
+  if (str.startsWith('class')) {
+    return `class ${fn.name || 'anonymous'}`;
+  }
+
+  // Fallback
+  const name = fn.name || 'anonymous';
+  const length = fn.length;
+  const params = Array(length).fill('arg').map((a, i) => `${a}${i}`).join(', ');
+  return `${name}(${params})`;
+}
+
+/**
+ * Get source code for a function (if available)
+ * @param {Function} fn
+ * @returns {string | undefined}
+ */
+export function getFunctionSource(fn) {
+  if (typeof fn !== 'function') return undefined;
+
+  try {
+    const source = fn.toString();
+    // Check if it's native code
+    if (source.includes('[native code]')) {
+      return undefined;
+    }
+    return source;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Get size description for a value
+ * @param {*} value
+ * @returns {string | undefined}
+ */
+export function getSizeDescription(value) {
+  if (Array.isArray(value)) {
+    return `${value.length} items`;
+  }
+  if (value instanceof Map || value instanceof Set) {
+    return `${value.size} items`;
+  }
+  if (typeof value === 'string') {
+    return `${value.length} chars`;
+  }
+  if (typeof value === 'object' && value !== null) {
+    const keys = Object.keys(value);
+    return `${keys.length} keys`;
+  }
+  return undefined;
+}