@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/editor-completions/index.js

@@ -1,181 +1,1250 @@
-/**
- * Editor Completions - Public API
- *
- * Editor-agnostic completion utilities for Flow Weaver.
- * Use these with any editor (CodeMirror, VS Code, Monaco, etc.)
- */
-// Re-export types
-export * from './types.js';
-// Re-export utilities
-export { parseCompletionContext, getWordAtPosition, detectSymbolType, detectBlockType, } from './contextParser.js';
-export { getAnnotationCompletions, JSDOC_ANNOTATIONS } from './jsDocAnnotations.js';
-export { getDataTypeCompletions, DATA_TYPES } from './dataTypes.js';
-export { getDefinitionLocation } from './goToDefinition.js';
-export { getAnnotationValueCompletions } from './annotationValues.js';
-export { getModifierCompletions, getModifierValueCompletions } from './modifierCompletions.js';
-import { parseCompletionContext } from './contextParser.js';
-import { getAnnotationCompletions } from './jsDocAnnotations.js';
-import { getDataTypeCompletions } from './dataTypes.js';
-import { getAnnotationValueCompletions } from './annotationValues.js';
-import { getModifierCompletions, getModifierValueCompletions } from './modifierCompletions.js';
-/**
- * Get Flow Weaver completions for the current cursor position.
- *
- * This is the main entry point for editor integrations.
- *
- * @param lineText - The full text of the current line
- * @param cursorOffset - Cursor position within the line (0-based)
- * @param isInJSDoc - Whether the cursor is inside a JSDoc block
- * @param context - Optional workflow context for nodeType/port completions
- * @param precedingBlockLines - Optional lines from start of JSDoc block to cursor line
- * @returns Array of completion suggestions
- *
- * @example
- * ```typescript
- * // In a CodeMirror completion source:
- * const completions = getFlowWeaverCompletions(
- *   " * @inp",
- *   7,
- *   true
- * );
- * // Returns: [{ label: "@input", ... }]
- * ```
- */
-export function getFlowWeaverCompletions(lineText, cursorOffset, isInJSDoc, context, precedingBlockLines) {
-    // Parse the context to determine what completions to show
-    const completionContext = parseCompletionContext(lineText, cursorOffset, isInJSDoc, precedingBlockLines);
-    if (!completionContext) {
-        return [];
-    }
-    switch (completionContext.type) {
-        case 'annotation':
-            return getAnnotationCompletions(completionContext.prefix, completionContext.blockType, completionContext.existingAnnotations);
-        case 'dataType':
-            return getDataTypeCompletions(completionContext.prefix);
-        case 'nodeType':
-            return getNodeTypeCompletions(completionContext.prefix, context);
-        case 'nodeId':
-            return getNodeIdCompletions(completionContext.prefix, context);
-        case 'port':
-            return getPortCompletions(completionContext.nodeId || '', completionContext.portDirection || 'output', completionContext.prefix, context, completionContext.lineText);
-        case 'annotationValue':
-            return getAnnotationValueCompletions(completionContext.annotation || '', completionContext.prefix);
-        case 'modifier':
-            return getModifierCompletions(completionContext.annotation || null, completionContext.prefix);
-        case 'modifierValue':
-            return getModifierValueCompletions(completionContext.modifier || '', completionContext.prefix);
-        default:
-            return [];
-    }
-}
-/**
- * Get nodeType completions from workflow context.
- */
+import "../chunks/chunk-SEWDMQ6Q.js";
+
+// src/editor-completions/contextParser.ts
+var ANNOTATION_PATTERN = /@(\w*)$/;
+var DATA_TYPE_PATTERN = /@(?:input|output)\s+\{(\w*)$/;
+var NODE_TYPE_PATTERN = /@node\s+(\w+)\s+(\w*)$/;
+var CONNECT_NODE_PATTERN = /@connect\s+(\w*)$/;
+var CONNECT_SOURCE_PORT_PATTERN = /@connect\s+(\w+)\.(\w*)$/;
+var CONNECT_TARGET_NODE_PATTERN = /@connect\s+\w+\.\w+\s*->\s*(\w*)$/;
+var CONNECT_TARGET_PORT_PATTERN = /@connect\s+\w+\.\w+\s*->\s*(\w+)\.(\w*)$/;
+var EXECUTE_WHEN_VALUE_PATTERN = /@executeWhen\s+(\w*)$/;
+var FLOW_WEAVER_VALUE_PATTERN = /@flowWeaver\s+(\w*)$/;
+var COLOR_VALUE_PATTERN = /@color\s+(\w*)$/;
+var PATH_NODE_PATTERN = /@path\s+(?:\w+(?::\w+)?\s*->\s*)+(\w*)$/;
+var SCOPE_NODE_PATTERN = /@scope\s+\w+\s*\[(?:\w+\s*,\s*)*(\w*)$/;
+var MAP_PORT_PATTERN = /@map\s+\w+\s+\w+\s+over\s+(\w+)\.(\w*)$/;
+var MAP_OVER_NODE_PATTERN = /@map\s+\w+\s+\w+\s+over\s+(\w*)$/;
+var MAP_TYPE_PATTERN = /@map\s+\w+\s+(\w*)$/;
+var MAP_NODE_PATTERN = /@map\s+(\w*)$/;
+var MODIFIER_NAME_PATTERN = /\[(\w*)$/;
+var MODIFIER_VALUE_PATTERN = /\[(\w+):\s*(\w*)$/;
+function detectBlockType(precedingBlockLines) {
+  for (const line of precedingBlockLines) {
+    const match = line.match(/@flowWeaver\s+(nodeType|workflow)\b/);
+    if (match) {
+      return match[1];
+    }
+    if (/@flowWeaver\s*$/.test(line.trim()) || /@flowWeaver\s+(?!nodeType|workflow)\w/.test(line)) {
+      return "workflow";
+    }
+  }
+  return null;
+}
+function detectLineAnnotation(lineText) {
+  const match = lineText.match(/@(\w+)/);
+  return match ? "@" + match[1] : null;
+}
+function parseCompletionContext(lineText, cursorOffset, isInJSDoc, precedingBlockLines) {
+  if (!isInJSDoc) {
+    return null;
+  }
+  const textBeforeCursor = lineText.slice(0, cursorOffset);
+  const blockType = precedingBlockLines ? detectBlockType(precedingBlockLines) : null;
+  let match;
+  match = textBeforeCursor.match(MAP_PORT_PATTERN);
+  if (match) {
+    return {
+      type: "port",
+      lineText,
+      cursorOffset,
+      prefix: match[2],
+      nodeId: match[1],
+      portDirection: "output",
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(MAP_OVER_NODE_PATTERN);
+  if (match) {
+    return {
+      type: "nodeId",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(MAP_TYPE_PATTERN);
+  if (match) {
+    return {
+      type: "nodeType",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(MAP_NODE_PATTERN);
+  if (match) {
+    return {
+      type: "nodeId",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(PATH_NODE_PATTERN);
+  if (match) {
+    return {
+      type: "nodeId",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(SCOPE_NODE_PATTERN);
+  if (match) {
+    return {
+      type: "nodeId",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(CONNECT_TARGET_PORT_PATTERN);
+  if (match) {
+    return {
+      type: "port",
+      lineText,
+      cursorOffset,
+      prefix: match[2],
+      nodeId: match[1],
+      portDirection: "input",
+      // Target receives, so needs input port
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(CONNECT_TARGET_NODE_PATTERN);
+  if (match) {
+    return {
+      type: "nodeId",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(CONNECT_SOURCE_PORT_PATTERN);
+  if (match) {
+    return {
+      type: "port",
+      lineText,
+      cursorOffset,
+      prefix: match[2],
+      nodeId: match[1],
+      portDirection: "output",
+      // Source sends, so needs output port
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(CONNECT_NODE_PATTERN);
+  if (match) {
+    return {
+      type: "nodeId",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(NODE_TYPE_PATTERN);
+  if (match) {
+    return {
+      type: "nodeType",
+      lineText,
+      cursorOffset,
+      prefix: match[2],
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(DATA_TYPE_PATTERN);
+  if (match) {
+    return {
+      type: "dataType",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(MODIFIER_VALUE_PATTERN);
+  if (match) {
+    return {
+      type: "modifierValue",
+      lineText,
+      cursorOffset,
+      prefix: match[2],
+      modifier: match[1],
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(MODIFIER_NAME_PATTERN);
+  if (match) {
+    const lineAnnotation = detectLineAnnotation(lineText);
+    return {
+      type: "modifier",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      annotation: lineAnnotation ?? void 0,
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(EXECUTE_WHEN_VALUE_PATTERN);
+  if (match) {
+    return {
+      type: "annotationValue",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      annotation: "@executeWhen",
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(FLOW_WEAVER_VALUE_PATTERN);
+  if (match) {
+    return {
+      type: "annotationValue",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      annotation: "@flowWeaver",
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(COLOR_VALUE_PATTERN);
+  if (match) {
+    return {
+      type: "annotationValue",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      annotation: "@color",
+      blockType
+    };
+  }
+  match = textBeforeCursor.match(ANNOTATION_PATTERN);
+  if (match) {
+    let existingAnnotations;
+    if (precedingBlockLines) {
+      const annotations = [];
+      for (const line of precedingBlockLines) {
+        const annoMatch = line.match(/@(\w+)/);
+        if (annoMatch) {
+          annotations.push(annoMatch[1]);
+        }
+      }
+      if (annotations.length > 0) {
+        existingAnnotations = annotations;
+      }
+    }
+    return {
+      type: "annotation",
+      lineText,
+      cursorOffset,
+      prefix: match[1],
+      blockType,
+      existingAnnotations
+    };
+  }
+  return null;
+}
+function getWordAtPosition(lineText, offset) {
+  const charAtOffset = lineText[offset];
+  if (!/\w/.test(charAtOffset || "")) {
+    return null;
+  }
+  let start = offset;
+  let end = offset;
+  while (start > 0 && /\w/.test(lineText[start - 1])) {
+    start--;
+  }
+  while (end < lineText.length && /\w/.test(lineText[end])) {
+    end++;
+  }
+  if (start === end) {
+    return null;
+  }
+  return {
+    word: lineText.slice(start, end),
+    start,
+    end
+  };
+}
+function detectSymbolType(lineText, offset) {
+  const wordInfo = getWordAtPosition(lineText, offset);
+  if (!wordInfo) {
+    return null;
+  }
+  const { word, start } = wordInfo;
+  const textBefore = lineText.slice(0, start);
+  const nodeTypeMatch = textBefore.match(/@node\s+\w+\s+$/);
+  if (nodeTypeMatch) {
+    return { type: "nodeType", name: word };
+  }
+  const connectNodeMatch = textBefore.match(/@connect\s+$/);
+  if (connectNodeMatch) {
+    return { type: "nodeId", name: word };
+  }
+  const portMatch = textBefore.match(/@connect\s+(\w+)\.$/);
+  if (portMatch) {
+    return { type: "port", name: word, nodeId: portMatch[1] };
+  }
+  const targetNodeMatch = textBefore.match(/@connect\s+\w+\.\w+\s*->\s*$/);
+  if (targetNodeMatch) {
+    return { type: "nodeId", name: word };
+  }
+  const targetPortMatch = textBefore.match(/@connect\s+\w+\.\w+\s*->\s*(\w+)\.$/);
+  if (targetPortMatch) {
+    return { type: "port", name: word, nodeId: targetPortMatch[1] };
+  }
+  const sugarNodeMatch = textBefore.match(/@path\s+(?:(?:\w+(?::\w+)?\s*(?:->|,)\s*)*)$/);
+  if (sugarNodeMatch) {
+    return { type: "nodeId", name: word };
+  }
+  return null;
+}
+
+// src/editor-completions/jsDocAnnotations.ts
+var JSDOC_ANNOTATIONS = [
+  // Core annotations
+  {
+    label: "@flowWeaver",
+    detail: "Mark function as Flow Weaver workflow",
+    documentation: "Indicates this function should be parsed as a Flow Weaver workflow with visual node graph.",
+    insertText: "@flowWeaver ",
+    insertTextFormat: "plain",
+    kind: "annotation",
+    sortOrder: 0
+  },
+  {
+    label: "@flowWeaver nodeType",
+    detail: "Mark function as reusable node type",
+    documentation: "Defines a reusable node type that can be instantiated in workflows.",
+    insertText: "@flowWeaver nodeType",
+    insertTextFormat: "plain",
+    kind: "annotation",
+    sortOrder: 1
+  },
+  // Port definitions (nodeType-only)
+  {
+    label: "@input",
+    detail: "Define input port",
+    documentation: "Declares an input port for data or control flow.\nFormat: @input name - description",
+    insertText: "@input ${1:name}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 10,
+    blockTypes: ["nodeType"]
+  },
+  {
+    label: "@output",
+    detail: "Define output port",
+    documentation: "Declares an output port for data or control flow.\nFormat: @output name - description",
+    insertText: "@output ${1:name}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 11,
+    blockTypes: ["nodeType"]
+  },
+  {
+    label: "@step",
+    detail: "Define step (control flow) port",
+    documentation: "Declares a STEP port for control flow. Shorthand for @input name [type:STEP] or @output name [type:STEP].",
+    insertText: "@step ${1:name}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 12,
+    blockTypes: ["nodeType"]
+  },
+  // Node declarations (workflow-only)
+  {
+    label: "@node",
+    detail: "Declare node instance",
+    documentation: "Declares a node instance in the workflow.\nFormat: @node instanceId NodeTypeName",
+    insertText: "@node ${1:id} ${2:NodeType}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 20,
+    blockTypes: ["workflow"]
+  },
+  {
+    label: "@connect",
+    detail: "Define connection between ports",
+    documentation: "Connects an output port to an input port.\nFormat: @connect sourceNode.outPort -> targetNode.inPort",
+    insertText: "@connect ${1:from}.${2:port} -> ${3:to}.${4:port}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 21,
+    blockTypes: ["workflow"]
+  },
+  {
+    label: "@fwImport",
+    detail: "Import npm node type",
+    documentation: 'Imports a node type from an npm package.\nFormat: @fwImport name fn from "package"',
+    insertText: '@fwImport ${1:name} ${2:fn} from "${3:pkg}"',
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 22,
+    blockTypes: ["workflow"]
+  },
+  {
+    label: "@path",
+    detail: "Multi-node execution route",
+    documentation: "Declare a complete execution route through the graph with scope walking for data ports.\nFormat: @path Start -> nodeA:ok -> nodeB:fail -> Exit",
+    insertText: "@path Start -> ${1:node1} -> ${2:node2} -> Exit",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 25,
+    blockTypes: ["workflow"]
+  },
+  {
+    label: "@trigger",
+    detail: "Set workflow trigger (event or cron)",
+    documentation: 'Defines how this workflow is triggered.\nFormats:\n  @trigger event="my/event"\n  @trigger cron="0 9 * * *"\n  @trigger event="my/event" cron="0 9 * * *"',
+    insertText: '@trigger ${1|event,cron|}="${2:value}"',
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 15,
+    blockTypes: ["workflow"]
+  },
+  {
+    label: "@http",
+    detail: "Serve the workflow on an HTTP route",
+    documentation: "Makes the workflow an endpoint of fw serve and the embeddable server. Path :params bind to workflow params by name. GET reads the query string, other methods the JSON body. The return ports are the response.\nFormats:\n  @http POST /reviews\n  @http GET /reviews/:id\n  @http POST /reviews mode=async callback\n  @http POST /hooks/github auth=none",
+    insertText: "@http ${1|POST,GET,PUT,PATCH,DELETE|} /${2:path}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 15,
+    blockTypes: ["workflow"]
+  },
+  {
+    label: "@cancelOn",
+    detail: "Cancel on external event",
+    documentation: 'Cancels a running workflow when a matching event arrives.\nFormat: @cancelOn event="app/user.deleted" match="data.userId"',
+    insertText: '@cancelOn event="${1:event/name}" match="${2:data.field}"',
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 16,
+    blockTypes: ["workflow"]
+  },
+  {
+    label: "@retries",
+    detail: "Set retry count",
+    documentation: "Number of times to retry on failure.\nFormat: @retries 5",
+    insertText: "@retries ${1:3}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 17,
+    blockTypes: ["workflow"]
+  },
+  {
+    label: "@timeout",
+    detail: "Set function timeout",
+    documentation: 'Maximum execution time before function is terminated.\nFormat: @timeout "30m"',
+    insertText: '@timeout "${1:30m}"',
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 18,
+    blockTypes: ["workflow"]
+  },
+  {
+    label: "@throttle",
+    detail: "Rate limit execution",
+    documentation: 'Limits execution rate to prevent overwhelming downstream services.\nFormat: @throttle limit=3 period="1m"',
+    insertText: '@throttle limit=${1:3} period="${2:1m}"',
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 19,
+    blockTypes: ["workflow"]
+  },
+  {
+    label: "@strictTypes",
+    detail: "Strict type checking",
+    documentation: "Enables strict type checking for connections in this workflow.",
+    insertText: "@strictTypes",
+    insertTextFormat: "plain",
+    kind: "annotation",
+    sortOrder: 24,
+    blockTypes: ["workflow"]
+  },
+  // Metadata (both or specific)
+  {
+    label: "@label",
+    detail: "Set display label",
+    documentation: "Sets a human-readable label for the workflow or node.",
+    insertText: '@label "${1:Label}"',
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 30
+  },
+  {
+    label: "@scope",
+    detail: "Define iteration scope",
+    documentation: "Defines a scope for iteration patterns (forEach, map, etc.).",
+    insertText: "@scope ${1:scopeName}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 31,
+    blockTypes: ["nodeType"]
+  },
+  {
+    label: "@name",
+    detail: "Set node type name",
+    documentation: "Sets the display name for a node type.",
+    insertText: "@name ${1:name}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 33,
+    blockTypes: ["nodeType"]
+  },
+  {
+    label: "@description",
+    detail: "Set description",
+    documentation: "Sets the description for a node type or workflow.",
+    insertText: "@description ${1:text}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 34,
+    blockTypes: ["nodeType"]
+  },
+  {
+    label: "@color",
+    detail: "Set node color",
+    documentation: "Sets the visual color of a node type in the editor.",
+    insertText: "@color ${1:color}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 35,
+    blockTypes: ["nodeType"]
+  },
+  {
+    label: "@icon",
+    detail: "Set node icon",
+    documentation: "Sets the icon for a node type.",
+    insertText: "@icon ${1:iconName}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 36,
+    blockTypes: ["nodeType"]
+  },
+  {
+    label: "@tag",
+    detail: "Add category tag",
+    documentation: "Adds a category tag to a node type for filtering and organization.",
+    insertText: "@tag ${1:tagName}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 37,
+    blockTypes: ["nodeType"]
+  },
+  {
+    label: "@expression",
+    detail: "Mark as expression node",
+    documentation: "Marks this node type as an expression node (pure data transformation, no control flow).",
+    insertText: "@expression",
+    insertTextFormat: "plain",
+    kind: "annotation",
+    sortOrder: 38,
+    blockTypes: ["nodeType"]
+  },
+  {
+    label: "@pullExecution",
+    detail: "Pull execution mode",
+    documentation: "Enables pull-based execution for this node type.",
+    insertText: "@pullExecution",
+    insertTextFormat: "plain",
+    kind: "annotation",
+    sortOrder: 39,
+    blockTypes: ["nodeType"]
+  },
+  {
+    label: "@executeWhen",
+    detail: "Execution strategy",
+    documentation: "Sets the execution strategy for this node type.\nValues: CONJUNCTION, DISJUNCTION, CUSTOM",
+    insertText: "@executeWhen ${1:CONJUNCTION}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 40,
+    blockTypes: ["nodeType"]
+  },
+  {
+    label: "@resilience",
+    detail: "Declare adapter-owned retry/fallback handling",
+    documentation: 'Makes retry or fallback behavior hidden in a shared adapter visible to static agent validation.\nFormat: @resilience retries=3 fallback="backup-provider"',
+    insertText: '@resilience retries=${1:3} fallback="${2:backup-provider}"',
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 41,
+    blockTypes: ["nodeType"]
+  },
+  // Standard JSDoc (for completeness)
+  {
+    label: "@param",
+    detail: "Document parameter",
+    documentation: "Standard JSDoc parameter documentation.",
+    insertText: "@param {${1:type}} ${2:name} - ${3:description}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 50
+  },
+  {
+    label: "@returns",
+    detail: "Document return value",
+    documentation: "Standard JSDoc return value documentation.",
+    insertText: "@returns {${1:type}} ${2:description}",
+    insertTextFormat: "snippet",
+    kind: "annotation",
+    sortOrder: 51
+  }
+];
+var CONNECTION_ANNOTATIONS = /* @__PURE__ */ new Set(["connect", "path"]);
+function getAnnotationCompletions(prefix, blockType, existingAnnotations) {
+  const lowerPrefix = prefix.toLowerCase();
+  const existing = existingAnnotations ? new Set(existingAnnotations) : void 0;
+  return JSDOC_ANNOTATIONS.filter((c) => {
+    if (!c.label.toLowerCase().startsWith("@" + lowerPrefix)) {
+      return false;
+    }
+    if (blockType && c.blockTypes) {
+      return c.blockTypes.includes(blockType);
+    }
+    return true;
+  }).map((c) => {
+    if (!existing) return c;
+    let boost = 0;
+    const annotationName = c.label.replace("@", "");
+    if (blockType === "workflow") {
+      const hasNode = existing.has("node");
+      const hasConnection = [...CONNECTION_ANNOTATIONS].some((a) => existing.has(a));
+      if (hasNode && !hasConnection && CONNECTION_ANNOTATIONS.has(annotationName)) {
+        boost = -10;
+      }
+    } else if (blockType === "nodeType") {
+      const hasInput = existing.has("input");
+      const hasOutput = existing.has("output");
+      if (!hasInput && annotationName === "input") {
+        boost = -10;
+      } else if (hasInput && !hasOutput && annotationName === "output") {
+        boost = -10;
+      }
+    }
+    if (boost === 0) return c;
+    return { ...c, sortOrder: (c.sortOrder ?? 0) + boost };
+  }).sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
+}
+
+// src/editor-completions/dataTypes.ts
+var DATA_TYPES = [
+  // Control flow
+  {
+    label: "STEP",
+    detail: "Control flow port",
+    documentation: "A control flow port that triggers execution. Used for sequencing nodes.",
+    insertText: "STEP}",
+    insertTextFormat: "plain",
+    kind: "type",
+    sortOrder: 0
+  },
+  // Primitive types
+  {
+    label: "String",
+    detail: "Text value",
+    documentation: "A string/text value.",
+    insertText: "String}",
+    insertTextFormat: "plain",
+    kind: "type",
+    sortOrder: 10
+  },
+  {
+    label: "Number",
+    detail: "Numeric value",
+    documentation: "A numeric value (integer or floating point).",
+    insertText: "Number}",
+    insertTextFormat: "plain",
+    kind: "type",
+    sortOrder: 11
+  },
+  {
+    label: "Boolean",
+    detail: "True/false value",
+    documentation: "A boolean true/false value.",
+    insertText: "Boolean}",
+    insertTextFormat: "plain",
+    kind: "type",
+    sortOrder: 12
+  },
+  // Complex types
+  {
+    label: "Array",
+    detail: "List of values",
+    documentation: "An array/list of values.",
+    insertText: "Array}",
+    insertTextFormat: "plain",
+    kind: "type",
+    sortOrder: 20
+  },
+  {
+    label: "Object",
+    detail: "Key-value object",
+    documentation: "A JavaScript object with key-value pairs.",
+    insertText: "Object}",
+    insertTextFormat: "plain",
+    kind: "type",
+    sortOrder: 21
+  },
+  {
+    label: "Function",
+    detail: "Callable function",
+    documentation: "A function reference.",
+    insertText: "Function}",
+    insertTextFormat: "plain",
+    kind: "type",
+    sortOrder: 22
+  },
+  // Generic
+  {
+    label: "Any",
+    detail: "Any type",
+    documentation: "Accepts any type of value.",
+    insertText: "Any}",
+    insertTextFormat: "plain",
+    kind: "type",
+    sortOrder: 30
+  }
+];
+function getDataTypeCompletions(prefix) {
+  const lowerPrefix = prefix.toLowerCase();
+  return DATA_TYPES.filter(
+    (c) => c.label.toLowerCase().startsWith(lowerPrefix)
+  );
+}
+
+// src/editor-completions/goToDefinition.ts
+function getDefinitionLocation(lineText, offset, context) {
+  const symbolInfo = detectSymbolType(lineText, offset);
+  if (!symbolInfo) {
+    return null;
+  }
+  switch (symbolInfo.type) {
+    case "nodeType":
+      return findNodeTypeDefinition(symbolInfo.name, context);
+    case "nodeId":
+      return findNodeDefinition(symbolInfo.name, context);
+    case "port":
+      return findPortDefinition(symbolInfo.name, symbolInfo.nodeId, context);
+  }
+}
+function findNodeTypeDefinition(name, context) {
+  const nodeType = context.nodeTypes[name];
+  if (!nodeType) {
+    return null;
+  }
+  return {
+    type: "nodeType",
+    name,
+    filePath: nodeType.filePath,
+    line: nodeType.line
+  };
+}
+function findNodeDefinition(id, context) {
+  const instance = context.instances?.find((inst) => inst.id === id);
+  if (!instance) {
+    return null;
+  }
+  const nodeType = context.nodeTypes[instance.nodeType];
+  if (nodeType) {
+    return {
+      type: "node",
+      name: id,
+      filePath: nodeType.filePath,
+      line: nodeType.line
+    };
+  }
+  return {
+    type: "node",
+    name: id
+  };
+}
+function findPortDefinition(portName, nodeId, context) {
+  if (!nodeId) {
+    return null;
+  }
+  const instance = context.instances?.find((inst) => inst.id === nodeId);
+  if (!instance) {
+    return null;
+  }
+  const nodeType = context.nodeTypes[instance.nodeType];
+  if (!nodeType) {
+    return null;
+  }
+  const port = nodeType.ports.find((p) => p.name === portName);
+  if (!port) {
+    return null;
+  }
+  return {
+    type: "port",
+    name: portName,
+    filePath: nodeType.filePath,
+    line: nodeType.line
+    // Ideally we'd have per-port line numbers
+  };
+}
+
+// src/editor-completions/annotationValues.ts
+var ANNOTATION_VALUES = {
+  "@executeWhen": [
+    {
+      label: "CONJUNCTION",
+      detail: "All inputs required",
+      documentation: "Node executes when ALL connected input step ports have fired.",
+      insertText: "CONJUNCTION",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 0
+    },
+    {
+      label: "DISJUNCTION",
+      detail: "Any input triggers",
+      documentation: "Node executes when ANY connected input step port has fired.",
+      insertText: "DISJUNCTION",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 1
+    },
+    {
+      label: "CUSTOM",
+      detail: "Custom execution logic",
+      documentation: "Node uses custom logic to determine when to execute.",
+      insertText: "CUSTOM",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 2
+    }
+  ],
+  "@flowWeaver": [
+    {
+      label: "workflow",
+      detail: "Visual workflow",
+      documentation: "Marks this function as a Flow Weaver workflow with a visual node graph.",
+      insertText: "workflow",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 0
+    },
+    {
+      label: "nodeType",
+      detail: "Reusable node type",
+      documentation: "Defines a reusable node type that can be instantiated in workflows.",
+      insertText: "nodeType",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 1
+    }
+  ],
+  "@color": [
+    {
+      label: "purple",
+      detail: "Purple node color",
+      insertText: "purple",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 0
+    },
+    {
+      label: "blue",
+      detail: "Blue node color",
+      insertText: "blue",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 1
+    },
+    {
+      label: "green",
+      detail: "Green node color",
+      insertText: "green",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 2
+    },
+    {
+      label: "orange",
+      detail: "Orange node color",
+      insertText: "orange",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 3
+    },
+    {
+      label: "red",
+      detail: "Red node color",
+      insertText: "red",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 4
+    },
+    {
+      label: "teal",
+      detail: "Teal node color (alias for cyan)",
+      insertText: "teal",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 5
+    },
+    {
+      label: "pink",
+      detail: "Pink node color",
+      insertText: "pink",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 6
+    },
+    {
+      label: "yellow",
+      detail: "Yellow node color",
+      insertText: "yellow",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 7
+    },
+    {
+      label: "cyan",
+      detail: "Cyan node color",
+      insertText: "cyan",
+      insertTextFormat: "plain",
+      kind: "value",
+      sortOrder: 8
+    }
+  ]
+};
+function getAnnotationValueCompletions(annotation, prefix) {
+  const values = ANNOTATION_VALUES[annotation];
+  if (!values) {
+    return [];
+  }
+  const lowerPrefix = prefix.toLowerCase();
+  return values.filter((v) => v.label.toLowerCase().startsWith(lowerPrefix));
+}
+
+// src/editor-completions/modifierCompletions.ts
+var PORT_MODIFIERS = [
+  { name: "order", detail: "Port display order", annotations: ["@input", "@output", "@step"] },
+  {
+    name: "placement",
+    detail: "Port placement (TOP/BOTTOM)",
+    annotations: ["@input", "@output", "@step"]
+  },
+  { name: "type", detail: "Override port data type", annotations: ["@input", "@output", "@step"] },
+  { name: "hidden", detail: "Hide port from UI", annotations: ["@input", "@output", "@step"] },
+  {
+    name: "optional",
+    detail: "Mark port as optional",
+    annotations: ["@input", "@output", "@step"]
+  },
+  {
+    name: "label",
+    detail: "Port display label",
+    annotations: ["@input", "@output", "@step", "@node"]
+  },
+  {
+    name: "expr",
+    detail: "Default expression",
+    annotations: ["@input", "@output", "@step", "@node"]
+  },
+  {
+    name: "minimized",
+    detail: "Start minimized",
+    annotations: ["@input", "@output", "@step", "@node"]
+  },
+  {
+    name: "pullExecution",
+    detail: "Pull execution mode",
+    annotations: ["@input", "@output", "@step", "@node"]
+  }
+];
+var NODE_MODIFIERS = [
+  { name: "label", detail: "Node display label", annotations: ["@node"] },
+  { name: "expr", detail: "Node expression", annotations: ["@node"] },
+  { name: "minimized", detail: "Start minimized", annotations: ["@node"] },
+  { name: "pullExecution", detail: "Pull execution mode", annotations: ["@node"] },
+  { name: "portOrder", detail: "Port display order", annotations: ["@node"] },
+  { name: "portLabel", detail: "Port label override", annotations: ["@node"] },
+  { name: "size", detail: "Node size", annotations: ["@node"] }
+];
+var ALL_MODIFIERS = [...PORT_MODIFIERS, ...NODE_MODIFIERS];
+var UNIQUE_MODIFIERS = [];
+var seen = /* @__PURE__ */ new Set();
+for (const mod of ALL_MODIFIERS) {
+  if (!seen.has(mod.name)) {
+    seen.add(mod.name);
+    const allAnnotations = ALL_MODIFIERS.filter((m) => m.name === mod.name).flatMap(
+      (m) => m.annotations || []
+    );
+    UNIQUE_MODIFIERS.push({
+      ...mod,
+      annotations: allAnnotations.length > 0 ? [...new Set(allAnnotations)] : null
+    });
+  }
+}
+var MODIFIER_VALUES = {
+  placement: [
+    {
+      label: "TOP",
+      detail: "Place port on top",
+      insertText: "TOP",
+      insertTextFormat: "plain",
+      kind: "value"
+    },
+    {
+      label: "BOTTOM",
+      detail: "Place port on bottom",
+      insertText: "BOTTOM",
+      insertTextFormat: "plain",
+      kind: "value"
+    }
+  ],
+  hidden: [
+    {
+      label: "true",
+      detail: "Hide port",
+      insertText: "true",
+      insertTextFormat: "plain",
+      kind: "value"
+    },
+    {
+      label: "false",
+      detail: "Show port",
+      insertText: "false",
+      insertTextFormat: "plain",
+      kind: "value"
+    }
+  ],
+  optional: [
+    {
+      label: "true",
+      detail: "Mark as optional",
+      insertText: "true",
+      insertTextFormat: "plain",
+      kind: "value"
+    },
+    {
+      label: "false",
+      detail: "Mark as required",
+      insertText: "false",
+      insertTextFormat: "plain",
+      kind: "value"
+    }
+  ],
+  minimized: [
+    {
+      label: "true",
+      detail: "Start minimized",
+      insertText: "true",
+      insertTextFormat: "plain",
+      kind: "value"
+    },
+    {
+      label: "false",
+      detail: "Start expanded",
+      insertText: "false",
+      insertTextFormat: "plain",
+      kind: "value"
+    }
+  ],
+  pullExecution: [
+    {
+      label: "true",
+      detail: "Enable pull execution",
+      insertText: "true",
+      insertTextFormat: "plain",
+      kind: "value"
+    },
+    {
+      label: "false",
+      detail: "Disable pull execution",
+      insertText: "false",
+      insertTextFormat: "plain",
+      kind: "value"
+    }
+  ]
+};
+function getModifierCompletions(lineAnnotation, prefix) {
+  const lowerPrefix = prefix.toLowerCase();
+  return UNIQUE_MODIFIERS.filter((mod) => {
+    if (!mod.name.toLowerCase().startsWith(lowerPrefix)) {
+      return false;
+    }
+    if (lineAnnotation && mod.annotations) {
+      return mod.annotations.includes(lineAnnotation);
+    }
+    return true;
+  }).map((mod, i) => ({
+    label: mod.name,
+    detail: mod.detail,
+    documentation: mod.documentation,
+    insertText: mod.name + ":",
+    insertTextFormat: "plain",
+    kind: "keyword",
+    sortOrder: i
+  }));
+}
+function getModifierValueCompletions(modifier, prefix) {
+  const values = MODIFIER_VALUES[modifier];
+  if (!values) {
+    return [];
+  }
+  const lowerPrefix = prefix.toLowerCase();
+  return values.filter((v) => v.label.toLowerCase().startsWith(lowerPrefix));
+}
+
+// src/editor-completions/index.ts
+function getFlowWeaverCompletions(lineText, cursorOffset, isInJSDoc, context, precedingBlockLines) {
+  const completionContext = parseCompletionContext(
+    lineText,
+    cursorOffset,
+    isInJSDoc,
+    precedingBlockLines
+  );
+  if (!completionContext) {
+    return [];
+  }
+  switch (completionContext.type) {
+    case "annotation":
+      return getAnnotationCompletions(
+        completionContext.prefix,
+        completionContext.blockType,
+        completionContext.existingAnnotations
+      );
+    case "dataType":
+      return getDataTypeCompletions(completionContext.prefix);
+    case "nodeType":
+      return getNodeTypeCompletions(completionContext.prefix, context);
+    case "nodeId":
+      return getNodeIdCompletions(completionContext.prefix, context);
+    case "port":
+      return getPortCompletions(
+        completionContext.nodeId || "",
+        completionContext.portDirection || "output",
+        completionContext.prefix,
+        context,
+        completionContext.lineText
+      );
+    case "annotationValue":
+      return getAnnotationValueCompletions(
+        completionContext.annotation || "",
+        completionContext.prefix
+      );
+    case "modifier":
+      return getModifierCompletions(completionContext.annotation || null, completionContext.prefix);
+    case "modifierValue":
+      return getModifierValueCompletions(
+        completionContext.modifier || "",
+        completionContext.prefix
+      );
+    case null:
+      return [];
+  }
+}
 function getNodeTypeCompletions(prefix, context) {
-    if (!context?.nodeTypes) {
-        return [];
-    }
-    const lowerPrefix = prefix.toLowerCase();
-    return Object.values(context.nodeTypes)
-        .filter((nt) => nt.name.toLowerCase().startsWith(lowerPrefix))
-        .map((nt) => ({
-        label: nt.name,
-        detail: nt.category,
-        documentation: nt.description,
-        insertText: nt.name,
-        insertTextFormat: 'plain',
-        kind: 'nodeType',
-    }));
-}
-/**
- * Get node instance ID completions from workflow context.
- */
+  if (!context?.nodeTypes) {
+    return [];
+  }
+  const lowerPrefix = prefix.toLowerCase();
+  return Object.values(context.nodeTypes).filter((nt) => nt.name.toLowerCase().startsWith(lowerPrefix)).map((nt) => ({
+    label: nt.name,
+    detail: nt.category,
+    documentation: nt.description,
+    insertText: nt.name,
+    insertTextFormat: "plain",
+    kind: "nodeType"
+  }));
+}
 function getNodeIdCompletions(prefix, context) {
-    if (!context?.instances) {
-        return [];
-    }
-    const lowerPrefix = prefix.toLowerCase();
-    return context.instances
-        .filter((inst) => inst.id.toLowerCase().startsWith(lowerPrefix))
-        .map((inst) => ({
-        label: inst.id,
-        detail: inst.nodeType,
-        insertText: inst.id,
-        insertTextFormat: 'plain',
-        kind: 'node',
-    }));
-}
-/**
- * Get port completions for a specific node.
- * When completing target ports (input), sorts type-matching ports first
- * and demotes already-connected ports.
- */
+  if (!context?.instances) {
+    return [];
+  }
+  const lowerPrefix = prefix.toLowerCase();
+  return context.instances.filter((inst) => inst.id.toLowerCase().startsWith(lowerPrefix)).map((inst) => ({
+    label: inst.id,
+    detail: inst.nodeType,
+    insertText: inst.id,
+    insertTextFormat: "plain",
+    kind: "node"
+  }));
+}
 function getPortCompletions(nodeId, direction, prefix, context, lineText) {
-    if (!context?.instances || !context?.nodeTypes) {
-        return [];
-    }
-    // Find the node instance
-    const instance = context.instances.find((inst) => inst.id === nodeId);
-    if (!instance) {
-        return [];
-    }
-    // Find the node type
-    const nodeType = context.nodeTypes[instance.nodeType];
-    if (!nodeType) {
-        return [];
-    }
-    // Filter ports by direction
-    const directionUpper = direction.toUpperCase();
-    const lowerPrefix = prefix.toLowerCase();
-    // Resolve source port dataType when completing target (input) ports
-    let sourceDataType;
-    if (direction === 'input' && lineText) {
-        const sourceMatch = lineText.match(/@connect\s+(\w+)\.(\w+)\s*->/);
-        if (sourceMatch) {
-            const [, srcNodeId, srcPortName] = sourceMatch;
-            const srcInstance = context.instances.find((inst) => inst.id === srcNodeId);
-            if (srcInstance) {
-                const srcNodeType = context.nodeTypes[srcInstance.nodeType];
-                if (srcNodeType) {
-                    const srcPort = srcNodeType.ports.find((p) => p.name === srcPortName && p.direction === 'OUTPUT');
-                    sourceDataType = srcPort?.dataType;
-                }
-            }
+  if (!context?.instances || !context?.nodeTypes) {
+    return [];
+  }
+  const instance = context.instances.find((inst) => inst.id === nodeId);
+  if (!instance) {
+    return [];
+  }
+  const nodeType = context.nodeTypes[instance.nodeType];
+  if (!nodeType) {
+    return [];
+  }
+  const directionUpper = direction.toUpperCase();
+  const lowerPrefix = prefix.toLowerCase();
+  let sourceDataType;
+  if (direction === "input" && lineText) {
+    const sourceMatch = lineText.match(/@connect\s+(\w+)\.(\w+)\s*->/);
+    if (sourceMatch) {
+      const [, srcNodeId, srcPortName] = sourceMatch;
+      const srcInstance = context.instances.find((inst) => inst.id === srcNodeId);
+      if (srcInstance) {
+        const srcNodeType = context.nodeTypes[srcInstance.nodeType];
+        if (srcNodeType) {
+          const srcPort = srcNodeType.ports.find(
+            (p) => p.name === srcPortName && p.direction === "OUTPUT"
+          );
+          sourceDataType = srcPort?.dataType;
         }
+      }
     }
-    // Build set of already-connected ports on this node (for the given direction)
-    const connectedPorts = new Set();
-    if (context.connections) {
-        for (const conn of context.connections) {
-            if (direction === 'input' && conn.targetNode === nodeId) {
-                connectedPorts.add(conn.targetPort);
-            }
-            else if (direction === 'output' && conn.sourceNode === nodeId) {
-                connectedPorts.add(conn.sourcePort);
-            }
-        }
+  }
+  const connectedPorts = /* @__PURE__ */ new Set();
+  if (context.connections) {
+    for (const conn of context.connections) {
+      if (direction === "input" && conn.targetNode === nodeId) {
+        connectedPorts.add(conn.targetPort);
+      } else if (direction === "output" && conn.sourceNode === nodeId) {
+        connectedPorts.add(conn.sourcePort);
+      }
     }
-    return nodeType.ports
-        .filter((port) => port.direction === directionUpper)
-        .filter((port) => port.name.toLowerCase().startsWith(lowerPrefix))
-        .map((port) => {
-        const isConnected = connectedPorts.has(port.name);
-        const isTypeMatch = sourceDataType && port.dataType === sourceDataType;
-        let sortOrder = 0;
-        if (isTypeMatch)
-            sortOrder = -10;
-        if (isConnected)
-            sortOrder = 20;
-        return {
-            label: port.name,
-            detail: isConnected ? `${port.dataType || ''} (connected)`.trim() : port.dataType,
-            documentation: port.description,
-            insertText: port.name,
-            insertTextFormat: 'plain',
-            kind: 'port',
-            sortOrder,
-        };
-    })
-        .sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
-}
-//# sourceMappingURL=index.js.map
+  }
+  return nodeType.ports.filter((port) => port.direction === directionUpper).filter((port) => port.name.toLowerCase().startsWith(lowerPrefix)).map((port) => {
+    const isConnected = connectedPorts.has(port.name);
+    const isTypeMatch = sourceDataType && port.dataType === sourceDataType;
+    let sortOrder = 0;
+    if (isTypeMatch) sortOrder = -10;
+    if (isConnected) sortOrder = 20;
+    return {
+      label: port.name,
+      detail: isConnected ? `${port.dataType || ""} (connected)`.trim() : port.dataType,
+      documentation: port.description,
+      insertText: port.name,
+      insertTextFormat: "plain",
+      kind: "port",
+      sortOrder
+    };
+  }).sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0));
+}
+export {
+  DATA_TYPES,
+  JSDOC_ANNOTATIONS,
+  detectBlockType,
+  detectSymbolType,
+  getAnnotationCompletions,
+  getAnnotationValueCompletions,
+  getDataTypeCompletions,
+  getDefinitionLocation,
+  getFlowWeaverCompletions,
+  getModifierCompletions,
+  getModifierValueCompletions,
+  getWordAtPosition,
+  parseCompletionContext
+};