@blokjs/lsp-server 0.2.0

package/src/constants.ts

@@ -0,0 +1,194 @@
+/**
+ * Shared constants for Blok workflow validation, completion, and documentation.
+ * These are IDE-agnostic and used by both the LSP server and VS Code extension.
+ */
+
+export const VALID_TRIGGERS = [
+	"http",
+	"grpc",
+	"manual",
+	"cron",
+	"queue",
+	"pubsub",
+	"worker",
+	"webhook",
+	"websocket",
+	"sse",
+] as const;
+
+export const VALID_HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "ANY"] as const;
+
+export const VALID_STEP_TYPES = [
+	"local",
+	"module",
+	"runtime.nodejs",
+	"runtime.python3",
+	"runtime.go",
+	"runtime.java",
+	"runtime.rust",
+	"runtime.php",
+	"runtime.csharp",
+	"runtime.ruby",
+] as const;
+
+export const VALID_RUNTIMES = [
+	"nodejs",
+	"bun",
+	"python3",
+	"go",
+	"java",
+	"rust",
+	"php",
+	"csharp",
+	"ruby",
+	"docker",
+	"wasm",
+] as const;
+
+export const QUEUE_PROVIDERS = ["kafka", "rabbitmq", "sqs", "redis", "beanstalk"] as const;
+
+export const PUBSUB_PROVIDERS = ["gcp", "aws", "azure", "redis", "nats"] as const;
+
+export const WEBHOOK_SOURCES = ["github", "stripe", "shopify", "custom"] as const;
+
+export const NODE_PACKAGES = [
+	{ name: "@blokjs/api-call", description: "HTTP API call node - makes requests to external services" },
+	{ name: "@blokjs/if-else", description: "Conditional branching node - evaluates conditions for routing" },
+	{ name: "@blokjs/react", description: "React SSR node - server-side rendering" },
+] as const;
+
+export interface WorkflowJson {
+	name?: unknown;
+	version?: unknown;
+	description?: unknown;
+	trigger?: Record<string, unknown>;
+	steps?: unknown[];
+	nodes?: Record<string, unknown>;
+}
+
+export interface HoverDoc {
+	title: string;
+	description: string;
+	example?: string;
+}
+
+export const TRIGGER_DOCS: Record<string, HoverDoc> = {
+	http: {
+		title: "HTTP Trigger",
+		description: "Triggers workflow on HTTP requests. Supports GET, POST, PUT, DELETE, PATCH, and ANY methods.",
+		example: `"http": {\n  "method": "POST",\n  "path": "/api/users",\n  "accept": "application/json"\n}`,
+	},
+	grpc: {
+		title: "gRPC Trigger",
+		description: "Triggers workflow on gRPC method calls using Connect RPC protocol.",
+		example: `"grpc": {\n  "service": "UserService",\n  "method": "GetUser"\n}`,
+	},
+	manual: {
+		title: "Manual Trigger",
+		description: "No automatic triggering. Workflow must be invoked programmatically.",
+		example: `"manual": {}`,
+	},
+	cron: {
+		title: "Cron Trigger",
+		description: "Triggers workflow on a schedule using cron expressions. Supports timezone and overlap control.",
+		example: `"cron": {\n  "schedule": "*/5 * * * *",\n  "timezone": "America/New_York",\n  "overlap": false\n}`,
+	},
+	queue: {
+		title: "Queue Trigger",
+		description:
+			"Triggers workflow when messages arrive on a queue. Supports Kafka, RabbitMQ, SQS, Redis, and Beanstalk.",
+		example: `"queue": {\n  "provider": "kafka",\n  "topic": "user-events",\n  "consumerGroup": "blok-workers"\n}`,
+	},
+	pubsub: {
+		title: "Pub/Sub Trigger",
+		description:
+			"Triggers workflow on pub/sub messages. Supports GCP Pub/Sub, AWS SNS, Azure Service Bus, Redis, and NATS.",
+		example: `"pubsub": {\n  "provider": "gcp",\n  "topic": "notifications",\n  "subscription": "blok-sub"\n}`,
+	},
+	worker: {
+		title: "Worker Trigger",
+		description: "Background job processing with configurable concurrency, timeouts, and retries.",
+		example: `"worker": {\n  "queue": "email-jobs",\n  "concurrency": 5,\n  "timeout": 30000,\n  "retries": 3\n}`,
+	},
+	webhook: {
+		title: "Webhook Trigger",
+		description: "Triggers workflow when external services send webhook events. Supports HMAC signature verification.",
+		example: `"webhook": {\n  "source": "github",\n  "events": ["push", "pull_request"],\n  "secret": "WEBHOOK_SECRET"\n}`,
+	},
+	websocket: {
+		title: "WebSocket Trigger",
+		description: "Real-time bidirectional communication. Supports rooms, authentication, and message rate limiting.",
+		example: `"websocket": {\n  "path": "/ws",\n  "events": ["message", "join", "leave"],\n  "maxConnections": 1000\n}`,
+	},
+	sse: {
+		title: "SSE Trigger",
+		description: "Server-Sent Events for real-time unidirectional streaming. Supports channels and replay.",
+		example: `"sse": {\n  "path": "/events",\n  "channels": ["updates", "alerts"],\n  "retryInterval": 3000\n}`,
+	},
+};
+
+export const FIELD_DOCS: Record<string, HoverDoc> = {
+	name: {
+		title: "Workflow Name",
+		description: "Human-readable name identifying this workflow. Used for logging, monitoring, and display purposes.",
+	},
+	version: {
+		title: "Workflow Version",
+		description: "Semantic version of this workflow (e.g., 1.0.0). Follows SemVer format: MAJOR.MINOR.PATCH.",
+	},
+	description: {
+		title: "Workflow Description",
+		description: "Detailed description of what this workflow does. Shown in documentation and monitoring dashboards.",
+	},
+	trigger: {
+		title: "Workflow Trigger",
+		description:
+			"Defines how this workflow is invoked. Each workflow has exactly one trigger type: http, grpc, manual, cron, queue, pubsub, worker, webhook, websocket, or sse.",
+	},
+	steps: {
+		title: "Workflow Steps",
+		description:
+			"Ordered array of steps to execute. Each step references a node and defines its type (local or module). Steps execute sequentially; use conditional nodes for branching.",
+	},
+	nodes: {
+		title: "Node Configurations",
+		description:
+			'Maps step names to their configurations. Each key matches a step\'s "name" field and contains inputs, conditions, or nested steps.',
+	},
+	inputs: {
+		title: "Node Inputs",
+		description:
+			"Input values for the node. Supports static values, template variables (${ctx.request.body.field}), JavaScript evaluation (js/ prefix), and context variable references.",
+		example: `"inputs": {\n  "url": "https://api.example.com/users",\n  "userId": "\${ctx.request.params.id}",\n  "computed": "js/ctx.response.data.items.length"\n}`,
+	},
+	conditions: {
+		title: "Conditional Branches",
+		description:
+			"Array of if/else conditions for branching logic. Use with @blokjs/if-else node. Each condition has a JavaScript expression and nested steps.",
+		example: `"conditions": [\n  {\n    "type": "if",\n    "condition": "ctx.request.query.type === 'admin'",\n    "steps": [...]\n  },\n  {\n    "type": "else",\n    "steps": [...]\n  }\n]`,
+	},
+	set_var: {
+		title: "Set Context Variable",
+		description:
+			"When true, stores the step's output in ctx.vars['step-name']. This makes the result accessible to downstream steps via ctx.vars.",
+		example: `"my-step": {\n  "set_var": true,\n  "inputs": { ... }\n}\n// Later: ctx.vars['my-step'] contains the result`,
+	},
+};
+
+export const STEP_FIELD_DOCS: Record<string, HoverDoc> = {
+	node: {
+		title: "Step Node Reference",
+		description:
+			"The node package or local path to execute. For modules: @blokjs/api-call. For local nodes: ./nodes/my-node.",
+	},
+	type: {
+		title: "Step Type",
+		description:
+			"How the node should be resolved.\n- **local**: Node defined in the project\n- **module**: npm package node\n- **runtime.X**: Language-specific runtime (nodejs, python3, go, java, rust, php, csharp, ruby)",
+	},
+	runtime: {
+		title: "Step Runtime",
+		description:
+			"Override the default runtime for this step. Available: nodejs, bun, python3, go, java, rust, php, csharp, ruby, docker, wasm.",
+	},
+};

package/src/diagnostics.ts

@@ -0,0 +1,493 @@
+import { type Diagnostic, DiagnosticSeverity, Position, Range } from "vscode-languageserver";
+import { VALID_HTTP_METHODS, VALID_RUNTIMES, VALID_STEP_TYPES, VALID_TRIGGERS, type WorkflowJson } from "./constants";
+
+/**
+ * Provides workflow validation diagnostics for the LSP server.
+ *
+ * Validates:
+ * - Required fields (name, version, trigger, steps, nodes)
+ * - Version format (semver)
+ * - Trigger configuration (type-specific validation)
+ * - Step structure (name, node, type)
+ * - Node configuration references
+ * - Unused nodes
+ * - Runtime field validation
+ */
+export function validateWorkflow(text: string): Diagnostic[] {
+	const diagnostics: Diagnostic[] = [];
+
+	let workflow: WorkflowJson;
+	try {
+		workflow = JSON.parse(text);
+	} catch {
+		diagnostics.push({
+			severity: DiagnosticSeverity.Error,
+			range: createRange(0, 0, 0, 1),
+			message: "Invalid JSON: failed to parse workflow file",
+			source: "blok",
+		});
+		return diagnostics;
+	}
+
+	if (typeof workflow !== "object" || workflow === null || Array.isArray(workflow)) {
+		diagnostics.push({
+			severity: DiagnosticSeverity.Error,
+			range: createRange(0, 0, 0, 1),
+			message: "Workflow must be a JSON object",
+			source: "blok",
+		});
+		return diagnostics;
+	}
+
+	validateRequiredFields(text, workflow, diagnostics);
+	validateVersion(text, workflow, diagnostics);
+	validateTrigger(text, workflow, diagnostics);
+	validateSteps(text, workflow, diagnostics);
+	validateNodeReferences(text, workflow, diagnostics);
+
+	return diagnostics;
+}
+
+function validateRequiredFields(text: string, workflow: WorkflowJson, diagnostics: Diagnostic[]): void {
+	const required: Array<{ key: keyof WorkflowJson; label: string }> = [
+		{ key: "name", label: "name" },
+		{ key: "version", label: "version" },
+		{ key: "trigger", label: "trigger" },
+		{ key: "steps", label: "steps" },
+		{ key: "nodes", label: "nodes" },
+	];
+
+	for (const { key, label } of required) {
+		if (workflow[key] === undefined) {
+			diagnostics.push({
+				severity: DiagnosticSeverity.Error,
+				range: createRange(0, 0, 0, 1),
+				message: `Missing required field: "${label}"`,
+				source: "blok",
+			});
+		}
+	}
+
+	if (typeof workflow.name === "string" && workflow.name.length === 0) {
+		const range = findKeyRange(text, "name");
+		diagnostics.push({
+			severity: DiagnosticSeverity.Error,
+			range,
+			message: "Workflow name cannot be empty",
+			source: "blok",
+		});
+	}
+}
+
+function validateVersion(text: string, workflow: WorkflowJson, diagnostics: Diagnostic[]): void {
+	if (typeof workflow.version !== "string") return;
+
+	const semverRegex = /^\d+\.\d+\.\d+$/;
+	if (!semverRegex.test(workflow.version)) {
+		const range = findKeyRange(text, "version");
+		diagnostics.push({
+			severity: DiagnosticSeverity.Warning,
+			range,
+			message: `Invalid version format "${workflow.version}". Expected semver (e.g., 1.0.0)`,
+			source: "blok",
+		});
+	}
+}
+
+function validateTrigger(text: string, workflow: WorkflowJson, diagnostics: Diagnostic[]): void {
+	if (!workflow.trigger || typeof workflow.trigger !== "object") return;
+
+	const triggerKeys = Object.keys(workflow.trigger);
+
+	if (triggerKeys.length === 0) {
+		const range = findKeyRange(text, "trigger");
+		diagnostics.push({
+			severity: DiagnosticSeverity.Error,
+			range,
+			message: "Trigger must have at least one type defined",
+			source: "blok",
+		});
+		return;
+	}
+
+	if (triggerKeys.length > 1) {
+		const range = findKeyRange(text, "trigger");
+		diagnostics.push({
+			severity: DiagnosticSeverity.Error,
+			range,
+			message: `Only one trigger type allowed per workflow. Found: ${triggerKeys.join(", ")}`,
+			source: "blok",
+		});
+	}
+
+	const triggerType = triggerKeys[0];
+	if (!VALID_TRIGGERS.includes(triggerType as (typeof VALID_TRIGGERS)[number])) {
+		const range = findKeyRange(text, triggerType);
+		diagnostics.push({
+			severity: DiagnosticSeverity.Error,
+			range,
+			message: `Unknown trigger type "${triggerType}". Valid types: ${VALID_TRIGGERS.join(", ")}`,
+			source: "blok",
+		});
+	}
+
+	// HTTP trigger validation
+	if (triggerType === "http") {
+		const httpConfig = workflow.trigger.http as Record<string, unknown> | undefined;
+		if (httpConfig && typeof httpConfig === "object") {
+			if (!httpConfig.method) {
+				const range = findKeyRange(text, "http");
+				diagnostics.push({
+					severity: DiagnosticSeverity.Error,
+					range,
+					message: 'HTTP trigger requires "method" field',
+					source: "blok",
+				});
+			} else if (
+				typeof httpConfig.method === "string" &&
+				!VALID_HTTP_METHODS.includes(httpConfig.method as (typeof VALID_HTTP_METHODS)[number])
+			) {
+				const range = findValueRange(text, "method", httpConfig.method as string);
+				diagnostics.push({
+					severity: DiagnosticSeverity.Error,
+					range,
+					message: `Invalid HTTP method "${httpConfig.method}". Valid: ${VALID_HTTP_METHODS.join(", ")}`,
+					source: "blok",
+				});
+			}
+			if (!httpConfig.path) {
+				const range = findKeyRange(text, "http");
+				diagnostics.push({
+					severity: DiagnosticSeverity.Error,
+					range,
+					message: 'HTTP trigger requires "path" field',
+					source: "blok",
+				});
+			}
+		}
+	}
+
+	// Cron trigger validation
+	if (triggerType === "cron") {
+		const cronConfig = workflow.trigger.cron as Record<string, unknown> | undefined;
+		if (cronConfig && typeof cronConfig === "object") {
+			if (!cronConfig.schedule) {
+				const range = findKeyRange(text, "cron");
+				diagnostics.push({
+					severity: DiagnosticSeverity.Error,
+					range,
+					message: 'Cron trigger requires "schedule" field',
+					source: "blok",
+				});
+			} else if (typeof cronConfig.schedule === "string") {
+				const parts = cronConfig.schedule.trim().split(/\s+/);
+				if (parts.length < 5 || parts.length > 6) {
+					const range = findValueRange(text, "schedule", cronConfig.schedule);
+					diagnostics.push({
+						severity: DiagnosticSeverity.Warning,
+						range,
+						message: "Invalid cron expression. Expected 5-6 fields (minute hour day month weekday [second])",
+						source: "blok",
+					});
+				}
+			}
+		}
+	}
+
+	// Queue trigger validation
+	if (triggerType === "queue") {
+		const queueConfig = workflow.trigger.queue as Record<string, unknown> | undefined;
+		if (queueConfig && typeof queueConfig === "object") {
+			if (!queueConfig.provider) {
+				const range = findKeyRange(text, "queue");
+				diagnostics.push({
+					severity: DiagnosticSeverity.Error,
+					range,
+					message: 'Queue trigger requires "provider" field',
+					source: "blok",
+				});
+			}
+			if (!queueConfig.topic) {
+				const range = findKeyRange(text, "queue");
+				diagnostics.push({
+					severity: DiagnosticSeverity.Error,
+					range,
+					message: 'Queue trigger requires "topic" field',
+					source: "blok",
+				});
+			}
+		}
+	}
+
+	// Webhook trigger validation
+	if (triggerType === "webhook") {
+		const webhookConfig = workflow.trigger.webhook as Record<string, unknown> | undefined;
+		if (webhookConfig && typeof webhookConfig === "object") {
+			if (!webhookConfig.source) {
+				const range = findKeyRange(text, "webhook");
+				diagnostics.push({
+					severity: DiagnosticSeverity.Error,
+					range,
+					message: 'Webhook trigger requires "source" field',
+					source: "blok",
+				});
+			}
+			if (!webhookConfig.events || !Array.isArray(webhookConfig.events)) {
+				const range = findKeyRange(text, "webhook");
+				diagnostics.push({
+					severity: DiagnosticSeverity.Error,
+					range,
+					message: 'Webhook trigger requires "events" array',
+					source: "blok",
+				});
+			}
+		}
+	}
+
+	// Pubsub trigger validation
+	if (triggerType === "pubsub") {
+		const pubsubConfig = workflow.trigger.pubsub as Record<string, unknown> | undefined;
+		if (pubsubConfig && typeof pubsubConfig === "object") {
+			if (!pubsubConfig.provider) {
+				const range = findKeyRange(text, "pubsub");
+				diagnostics.push({
+					severity: DiagnosticSeverity.Error,
+					range,
+					message: 'Pub/Sub trigger requires "provider" field',
+					source: "blok",
+				});
+			}
+			if (!pubsubConfig.topic && !pubsubConfig.channel) {
+				const range = findKeyRange(text, "pubsub");
+				diagnostics.push({
+					severity: DiagnosticSeverity.Error,
+					range,
+					message: 'Pub/Sub trigger requires "topic" or "channel" field',
+					source: "blok",
+				});
+			}
+		}
+	}
+
+	// Worker trigger validation
+	if (triggerType === "worker") {
+		const workerConfig = workflow.trigger.worker as Record<string, unknown> | undefined;
+		if (workerConfig && typeof workerConfig === "object") {
+			if (!workerConfig.queue) {
+				const range = findKeyRange(text, "worker");
+				diagnostics.push({
+					severity: DiagnosticSeverity.Error,
+					range,
+					message: 'Worker trigger requires "queue" field',
+					source: "blok",
+				});
+			}
+		}
+	}
+}
+
+function validateSteps(text: string, workflow: WorkflowJson, diagnostics: Diagnostic[]): void {
+	if (!Array.isArray(workflow.steps)) return;
+
+	const stepNames = new Set<string>();
+
+	for (let i = 0; i < workflow.steps.length; i++) {
+		const step = workflow.steps[i] as Record<string, unknown>;
+		if (!step || typeof step !== "object") {
+			diagnostics.push({
+				severity: DiagnosticSeverity.Error,
+				range: findArrayItemRange(text, "steps", i),
+				message: `Step ${i} must be an object`,
+				source: "blok",
+			});
+			continue;
+		}
+
+		if (!step.name || typeof step.name !== "string") {
+			diagnostics.push({
+				severity: DiagnosticSeverity.Error,
+				range: findArrayItemRange(text, "steps", i),
+				message: `Step ${i} is missing required "name" field`,
+				source: "blok",
+			});
+		} else {
+			if (stepNames.has(step.name)) {
+				diagnostics.push({
+					severity: DiagnosticSeverity.Warning,
+					range: findValueRange(text, "name", step.name),
+					message: `Duplicate step name "${step.name}"`,
+					source: "blok",
+				});
+			}
+			stepNames.add(step.name);
+		}
+
+		if (!step.node || typeof step.node !== "string") {
+			diagnostics.push({
+				severity: DiagnosticSeverity.Error,
+				range: findArrayItemRange(text, "steps", i),
+				message: `Step "${step.name || i}" is missing required "node" field`,
+				source: "blok",
+			});
+		}
+
+		if (!step.type || typeof step.type !== "string") {
+			diagnostics.push({
+				severity: DiagnosticSeverity.Error,
+				range: findArrayItemRange(text, "steps", i),
+				message: `Step "${step.name || i}" is missing required "type" field`,
+				source: "blok",
+			});
+		} else if (!VALID_STEP_TYPES.includes(step.type as (typeof VALID_STEP_TYPES)[number])) {
+			diagnostics.push({
+				severity: DiagnosticSeverity.Error,
+				range: findValueRange(text, "type", step.type),
+				message: `Invalid step type "${step.type}". Valid: ${VALID_STEP_TYPES.join(", ")}`,
+				source: "blok",
+			});
+		}
+
+		if (
+			step.runtime &&
+			typeof step.runtime === "string" &&
+			!VALID_RUNTIMES.includes(step.runtime as (typeof VALID_RUNTIMES)[number])
+		) {
+			diagnostics.push({
+				severity: DiagnosticSeverity.Error,
+				range: findValueRange(text, "runtime", step.runtime),
+				message: `Invalid runtime "${step.runtime}". Valid: ${VALID_RUNTIMES.join(", ")}`,
+				source: "blok",
+			});
+		}
+	}
+}
+
+function validateNodeReferences(text: string, workflow: WorkflowJson, diagnostics: Diagnostic[]): void {
+	if (!Array.isArray(workflow.steps) || typeof workflow.nodes !== "object" || !workflow.nodes) return;
+
+	const referencedNodes = collectStepNames(workflow.steps);
+	const definedNodes = new Set(Object.keys(workflow.nodes));
+
+	// Check for steps referencing undefined nodes
+	for (const stepName of referencedNodes) {
+		if (!definedNodes.has(stepName)) {
+			const range = findValueRange(text, "name", stepName);
+			diagnostics.push({
+				severity: DiagnosticSeverity.Warning,
+				range,
+				message: `Step "${stepName}" references a node that is not defined in "nodes"`,
+				source: "blok",
+			});
+		}
+	}
+
+	// Check for nodes with conditions and collect nested step names
+	const allReferenced = new Set(referencedNodes);
+	for (const [, nodeConfig] of Object.entries(workflow.nodes)) {
+		if (nodeConfig && typeof nodeConfig === "object") {
+			const cfg = nodeConfig as Record<string, unknown>;
+			if (Array.isArray(cfg.conditions)) {
+				for (const cond of cfg.conditions) {
+					if (cond && typeof cond === "object" && Array.isArray((cond as Record<string, unknown>).steps)) {
+						const nestedNames = collectStepNames((cond as Record<string, unknown>).steps as unknown[]);
+						for (const n of nestedNames) allReferenced.add(n);
+					}
+				}
+			}
+		}
+	}
+
+	// Check for unused nodes
+	for (const nodeName of definedNodes) {
+		if (!allReferenced.has(nodeName)) {
+			const range = findKeyRange(text, nodeName);
+			diagnostics.push({
+				severity: DiagnosticSeverity.Information,
+				range,
+				message: `Node "${nodeName}" is defined but not referenced by any step`,
+				source: "blok",
+			});
+		}
+	}
+}
+
+function collectStepNames(steps: unknown[]): Set<string> {
+	const names = new Set<string>();
+	for (const step of steps) {
+		if (step && typeof step === "object") {
+			const s = step as Record<string, unknown>;
+			if (typeof s.name === "string") {
+				names.add(s.name);
+			}
+		}
+	}
+	return names;
+}
+
+// --- Range helpers ---
+
+function createRange(startLine: number, startChar: number, endLine: number, endChar: number): Range {
+	return Range.create(Position.create(startLine, startChar), Position.create(endLine, endChar));
+}
+
+export function findKeyRange(text: string, key: string): Range {
+	const pattern = new RegExp(`"${escapeRegex(key)}"\\s*:`);
+	const match = pattern.exec(text);
+	if (match) {
+		const pos = offsetToPosition(text, match.index);
+		return createRange(pos.line, pos.character, pos.line, pos.character + match[0].length);
+	}
+	return createRange(0, 0, 0, 1);
+}
+
+export function findValueRange(text: string, key: string, value: string): Range {
+	const pattern = new RegExp(`"${escapeRegex(key)}"\\s*:\\s*"${escapeRegex(value)}"`);
+	const match = pattern.exec(text);
+	if (match) {
+		const pos = offsetToPosition(text, match.index);
+		return createRange(pos.line, pos.character, pos.line, pos.character + match[0].length);
+	}
+	return findKeyRange(text, key);
+}
+
+function findArrayItemRange(text: string, arrayKey: string, index: number): Range {
+	const keyMatch = new RegExp(`"${escapeRegex(arrayKey)}"\\s*:\\s*\\[`).exec(text);
+	if (!keyMatch) return createRange(0, 0, 0, 1);
+
+	let depth = 0;
+	let itemCount = 0;
+	const start = keyMatch.index + keyMatch[0].length;
+
+	for (let i = start; i < text.length; i++) {
+		if (text[i] === "{" || text[i] === "[") {
+			if (depth === 0 && itemCount === index) {
+				const pos = offsetToPosition(text, i);
+				return createRange(pos.line, pos.character, pos.line, pos.character + 1);
+			}
+			depth++;
+		} else if (text[i] === "}" || text[i] === "]") {
+			depth--;
+			if (depth === 0) itemCount++;
+		}
+	}
+
+	return createRange(0, 0, 0, 1);
+}
+
+export function offsetToPosition(text: string, offset: number): Position {
+	let line = 0;
+	let col = 0;
+	for (let i = 0; i < offset && i < text.length; i++) {
+		if (text[i] === "\n") {
+			line++;
+			col = 0;
+		} else {
+			col++;
+		}
+	}
+	return Position.create(line, col);
+}
+
+function escapeRegex(str: string): string {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}