@djodjonx/neosyringe-lsp 0.0.1

package/README.md

@@ -0,0 +1,17 @@
+# @djodjonx/neosyringe-lsp
+
+TypeScript Language Service Plugin for NeoSyringe. Provides real-time error detection in VSCode.
+
+## Setup
+
+Add to `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [{ "name": "@djodjonx/neosyringe-lsp" }]
+  }
+}
+```
+
+See [Documentation](https://djodjonx.github.io/neosyringe/guide/ide-plugin).

package/dist/index.cjs

@@ -0,0 +1,610 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let typescript = require("typescript");
+typescript = __toESM(typescript);
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+
+//#region ../core/src/analyzer/Analyzer.ts
+/**
+* Generates a unique, deterministic Token ID for a symbol.
+* Uses the symbol name and a short hash of its relative file path.
+*/
+function generateTokenId(symbol, sourceFile) {
+	const name = symbol.getName();
+	let relativePath = node_path.relative(process.cwd(), sourceFile.fileName);
+	relativePath = relativePath.split(node_path.sep).join("/");
+	return `${name}_${node_crypto.createHash("md5").update(relativePath).digest("hex").substring(0, 8)}`;
+}
+/**
+* Analyzes TypeScript source code to extract the dependency injection graph.
+*
+* This class uses the TypeScript Compiler API to:
+* 1. Locate `createContainer` calls.
+* 2. Parse the fluent chain of `bind` and `register` calls.
+* 3. Resolve symbols and types for services and their dependencies.
+* 4. Build a `DependencyGraph` representing the system.
+*/
+var Analyzer = class {
+	program;
+	checker;
+	/** Set of variable names that are parent containers (should not be added to main graph) */
+	parentContainerNames = /* @__PURE__ */ new Set();
+	/**
+	* Creates a new Analyzer instance.
+	* @param program - The TypeScript Program instance containing the source files to analyze.
+	*/
+	constructor(program) {
+		this.program = program;
+		this.checker = program.getTypeChecker();
+	}
+	/**
+	* Extracts the dependency graph from the program's source files.
+	*
+	* It scans all non-declaration source files for container configurations.
+	*
+	* @returns A `DependencyGraph` containing all registered services and their dependencies.
+	*/
+	extract() {
+		const graph = {
+			nodes: /* @__PURE__ */ new Map(),
+			roots: [],
+			buildArguments: []
+		};
+		for (const sourceFile of this.program.getSourceFiles()) {
+			if (sourceFile.isDeclarationFile) continue;
+			this.identifyParentContainers(sourceFile);
+		}
+		for (const sourceFile of this.program.getSourceFiles()) {
+			if (sourceFile.isDeclarationFile) continue;
+			this.visitNode(sourceFile, graph);
+		}
+		this.resolveAllDependencies(graph);
+		return graph;
+	}
+	/**
+	* First pass: identify containers used as parents so we can skip them in visitNode.
+	*/
+	identifyParentContainers(node) {
+		if (typescript.isPropertyAssignment(node) && typescript.isIdentifier(node.name) && node.name.text === "useContainer" && typescript.isIdentifier(node.initializer)) this.parentContainerNames.add(node.initializer.text);
+		typescript.forEachChild(node, (child) => this.identifyParentContainers(child));
+	}
+	/**
+	* Visits an AST node to find container calls.
+	* @param node - The AST node to visit.
+	* @param graph - The graph to populate.
+	*/
+	visitNode(node, graph) {
+		if (typescript.isCallExpression(node)) {
+			if (this.isDefineBuilderConfigCall(node)) {
+				const parent = node.parent;
+				if (typescript.isVariableDeclaration(parent) && typescript.isIdentifier(parent.name)) {
+					if (this.parentContainerNames.has(parent.name.text)) return;
+					graph.exportedVariableName = parent.name.text;
+					let current = parent;
+					while (current && !typescript.isVariableStatement(current)) current = current.parent;
+					if (current && typescript.isVariableStatement(current)) graph.variableStatementStart = current.getStart();
+				}
+				graph.defineBuilderConfigStart = node.getStart();
+				graph.defineBuilderConfigEnd = node.getEnd();
+				this.parseBuilderConfig(node, graph);
+			}
+		}
+		typescript.forEachChild(node, (child) => this.visitNode(child, graph));
+	}
+	isDefineBuilderConfigCall(node) {
+		const expression = node.expression;
+		if (typescript.isIdentifier(expression)) return expression.text === "defineBuilderConfig";
+		return false;
+	}
+	parseBuilderConfig(node, graph) {
+		const args = node.arguments;
+		if (args.length < 1) return;
+		const configObj = args[0];
+		if (!typescript.isObjectLiteralExpression(configObj)) return;
+		const nameProp = configObj.properties.find((p) => p.name && typescript.isIdentifier(p.name) && p.name.text === "name");
+		if (nameProp && typescript.isPropertyAssignment(nameProp) && typescript.isStringLiteral(nameProp.initializer)) graph.containerName = nameProp.initializer.text;
+		const injectionsProp = configObj.properties.find((p) => p.name && typescript.isIdentifier(p.name) && p.name.text === "injections");
+		if (injectionsProp && typescript.isPropertyAssignment(injectionsProp) && typescript.isArrayLiteralExpression(injectionsProp.initializer)) this.parseInjectionsArray(injectionsProp.initializer, graph);
+		const extendsProp = configObj.properties.find((p) => p.name && typescript.isIdentifier(p.name) && p.name.text === "extends");
+		if (extendsProp && typescript.isPropertyAssignment(extendsProp) && typescript.isArrayLiteralExpression(extendsProp.initializer)) this.parseExtendsArray(extendsProp.initializer, graph);
+		const useContainerProp = configObj.properties.find((p) => p.name && typescript.isIdentifier(p.name) && p.name.text === "useContainer");
+		if (useContainerProp && typescript.isPropertyAssignment(useContainerProp)) {
+			if (!graph.legacyContainers) graph.legacyContainers = [];
+			if (!graph.parentProvidedTokens) graph.parentProvidedTokens = /* @__PURE__ */ new Set();
+			const containerExpr = useContainerProp.initializer;
+			if (typescript.isIdentifier(containerExpr)) {
+				graph.legacyContainers.push(containerExpr.text);
+				this.extractParentContainerTokens(containerExpr, graph);
+			}
+		}
+	}
+	/**
+	* Extracts tokens provided by a parent container.
+	* Handles both NeoSyringe containers (defineBuilderConfig) and
+	* declared legacy containers (declareContainerTokens).
+	*/
+	extractParentContainerTokens(containerIdentifier, graph) {
+		const symbol = this.checker.getSymbolAtLocation(containerIdentifier);
+		if (!symbol) return;
+		this.parentContainerNames.add(containerIdentifier.text);
+		const resolvedSymbol = this.resolveSymbol(symbol);
+		const declaration = resolvedSymbol.valueDeclaration ?? resolvedSymbol.declarations?.[0];
+		if (!declaration) return;
+		if (typescript.isVariableDeclaration(declaration) && declaration.initializer) {
+			const init$1 = declaration.initializer;
+			if (typescript.isCallExpression(init$1)) {
+				if (this.isDefineBuilderConfigCall(init$1) || this.isDefinePartialConfigCall(init$1)) {
+					const parentGraph = {
+						nodes: /* @__PURE__ */ new Map(),
+						roots: []
+					};
+					this.parseBuilderConfig(init$1, parentGraph);
+					for (const tokenId of parentGraph.nodes.keys()) graph.parentProvidedTokens.add(tokenId);
+					if (parentGraph.parentProvidedTokens) for (const tokenId of parentGraph.parentProvidedTokens) graph.parentProvidedTokens.add(tokenId);
+					return;
+				}
+				if (this.isDeclareContainerTokensCall(init$1)) {
+					this.extractDeclaredTokens(init$1, graph);
+					return;
+				}
+			}
+		}
+	}
+	/**
+	* Checks if a call expression is declareContainerTokens<T>().
+	*/
+	isDeclareContainerTokensCall(node) {
+		if (typescript.isIdentifier(node.expression)) return node.expression.text === "declareContainerTokens";
+		return false;
+	}
+	/**
+	* Extracts tokens from declareContainerTokens<{ Token: Type }>().
+	* The type argument contains the token names.
+	*/
+	extractDeclaredTokens(node, graph) {
+		if (!node.typeArguments || node.typeArguments.length === 0) return;
+		const typeArg = node.typeArguments[0];
+		const properties = this.checker.getTypeFromTypeNode(typeArg).getProperties();
+		for (const prop of properties) {
+			const propType = this.checker.getTypeOfSymbol(prop);
+			if (propType) {
+				const tokenId = this.getTypeId(propType);
+				graph.parentProvidedTokens.add(tokenId);
+			} else graph.parentProvidedTokens.add(prop.getName());
+		}
+	}
+	parseExtendsArray(arrayLiteral, graph) {
+		for (const element of arrayLiteral.elements) if (typescript.isIdentifier(element)) this.parsePartialConfig(element, graph);
+	}
+	parsePartialConfig(identifier, graph) {
+		const symbol = this.checker.getSymbolAtLocation(identifier);
+		if (!symbol) return;
+		const resolvedSymbol = this.resolveSymbol(symbol);
+		const declaration = resolvedSymbol.valueDeclaration ?? resolvedSymbol.declarations?.[0];
+		if (!declaration) return;
+		if (typescript.isVariableDeclaration(declaration) && declaration.initializer && typescript.isCallExpression(declaration.initializer)) {
+			const callExpr = declaration.initializer;
+			if (this.isDefinePartialConfigCall(callExpr)) this.parseBuilderConfig(callExpr, graph);
+		}
+		if (typescript.isExportSpecifier(declaration)) {}
+	}
+	isDefinePartialConfigCall(node) {
+		const expression = node.expression;
+		if (typescript.isIdentifier(expression)) return expression.text === "definePartialConfig";
+		return false;
+	}
+	parseInjectionsArray(arrayLiteral, graph) {
+		for (const element of arrayLiteral.elements) if (typescript.isObjectLiteralExpression(element)) this.parseInjectionObject(element, graph);
+	}
+	parseInjectionObject(obj, graph) {
+		let tokenNode;
+		let providerNode;
+		let lifecycle = "singleton";
+		let useFactory = false;
+		let isScoped = false;
+		for (const prop of obj.properties) {
+			if (!typescript.isPropertyAssignment(prop) || !typescript.isIdentifier(prop.name)) continue;
+			if (prop.name.text === "token") tokenNode = prop.initializer;
+			else if (prop.name.text === "provider") providerNode = prop.initializer;
+			else if (prop.name.text === "lifecycle" && typescript.isStringLiteral(prop.initializer)) {
+				if (prop.initializer.text === "transient") lifecycle = "transient";
+			} else if (prop.name.text === "useFactory") {
+				if (prop.initializer.kind === typescript.SyntaxKind.TrueKeyword) useFactory = true;
+			} else if (prop.name.text === "scoped") {
+				if (prop.initializer.kind === typescript.SyntaxKind.TrueKeyword) isScoped = true;
+			}
+		}
+		if (!tokenNode) return;
+		if (providerNode && (typescript.isArrowFunction(providerNode) || typescript.isFunctionExpression(providerNode))) useFactory = true;
+		let tokenId;
+		let implementationSymbol;
+		let tokenSymbol;
+		let type = "autowire";
+		let isInterfaceToken = false;
+		let isValueToken = false;
+		let factorySource;
+		let resolvedTokenNode = tokenNode;
+		const resolved = this.resolveToInitializer(tokenNode);
+		if (resolved) resolvedTokenNode = resolved;
+		if (typescript.isCallExpression(resolvedTokenNode) && this.isUseInterfaceCall(resolvedTokenNode)) {
+			tokenId = this.extractInterfaceTokenId(resolvedTokenNode);
+			type = "explicit";
+			isInterfaceToken = true;
+		} else if (typescript.isCallExpression(resolvedTokenNode) && this.isUsePropertyCall(resolvedTokenNode)) {
+			const propertyInfo = this.extractPropertyTokenId(resolvedTokenNode);
+			tokenId = propertyInfo.tokenId;
+			type = "explicit";
+			isValueToken = true;
+			if (!providerNode) throw new Error(`useProperty(${propertyInfo.className}, '${propertyInfo.paramName}') requires a provider (factory).`);
+			useFactory = true;
+		} else {
+			const tokenType = this.checker.getTypeAtLocation(tokenNode);
+			tokenId = this.getTypeIdFromConstructor(tokenType);
+			if (typescript.isIdentifier(tokenNode)) tokenSymbol = this.checker.getSymbolAtLocation(tokenNode);
+		}
+		if (useFactory && providerNode) {
+			factorySource = providerNode.getText();
+			type = "factory";
+			if (tokenId) {
+				if (graph.nodes.has(tokenId) && !isScoped) throw new Error(`Duplicate registration: '${tokenId}' is already registered.`);
+				const definition = {
+					tokenId,
+					tokenSymbol: tokenSymbol ? this.resolveSymbol(tokenSymbol) : void 0,
+					registrationNode: obj,
+					type: "factory",
+					lifecycle,
+					isInterfaceToken,
+					isValueToken,
+					isFactory: true,
+					factorySource,
+					isScoped
+				};
+				graph.nodes.set(tokenId, {
+					service: definition,
+					dependencies: []
+				});
+			}
+			return;
+		}
+		if (providerNode) {
+			implementationSymbol = this.checker.getSymbolAtLocation(providerNode);
+			type = "explicit";
+		} else if (type === "explicit" && !providerNode) {
+			if (typescript.isIdentifier(tokenNode)) {
+				implementationSymbol = this.checker.getSymbolAtLocation(tokenNode);
+				type = "autowire";
+			}
+		} else if (typescript.isIdentifier(tokenNode)) {
+			implementationSymbol = this.checker.getSymbolAtLocation(tokenNode);
+			type = "autowire";
+		}
+		if (tokenId && implementationSymbol) {
+			if (graph.nodes.has(tokenId) && !isScoped) throw new Error(`Duplicate registration: '${tokenId}' is already registered.`);
+			const definition = {
+				tokenId,
+				implementationSymbol: this.resolveSymbol(implementationSymbol),
+				tokenSymbol: tokenSymbol ? this.resolveSymbol(tokenSymbol) : void 0,
+				registrationNode: obj,
+				type,
+				lifecycle,
+				isInterfaceToken: isInterfaceToken || typescript.isCallExpression(tokenNode) && this.isUseInterfaceCall(tokenNode),
+				isScoped
+			};
+			graph.nodes.set(tokenId, {
+				service: definition,
+				dependencies: []
+			});
+		}
+	}
+	isUseInterfaceCall(node) {
+		if (typescript.isIdentifier(node.expression)) return node.expression.text === "useInterface";
+		return false;
+	}
+	isUsePropertyCall(node) {
+		if (typescript.isIdentifier(node.expression)) return node.expression.text === "useProperty";
+		return false;
+	}
+	/**
+	* Resolves a node to its original initializer expression.
+	* Handles identifiers, property access, imports, and unwraps type assertions/casts.
+	*/
+	resolveToInitializer(node) {
+		let expr = node;
+		while (typescript.isParenthesizedExpression(expr) || typescript.isAsExpression(expr) || typescript.isTypeAssertionExpression(expr) || typescript.isSatisfiesExpression && typescript.isSatisfiesExpression(expr)) expr = expr.expression;
+		if (typescript.isCallExpression(expr)) return expr;
+		if (typescript.isIdentifier(expr)) return this.resolveIdentifierToInitializer(expr);
+		if (typescript.isPropertyAccessExpression(expr)) return this.resolvePropertyAccessToInitializer(expr);
+	}
+	resolveIdentifierToInitializer(identifier) {
+		const symbol = this.checker.getSymbolAtLocation(identifier);
+		if (!symbol) return void 0;
+		const declarations = this.resolveSymbol(symbol).getDeclarations();
+		if (!declarations || declarations.length === 0) return void 0;
+		for (const decl of declarations) if (typescript.isVariableDeclaration(decl) && decl.initializer) return this.resolveToInitializer(decl.initializer) ?? decl.initializer;
+	}
+	resolvePropertyAccessToInitializer(node) {
+		const objectInitializer = this.resolveToInitializer(node.expression);
+		if (objectInitializer && typescript.isObjectLiteralExpression(objectInitializer)) {
+			const propName = node.name.text;
+			const prop = objectInitializer.properties.find((p) => p.name && typescript.isIdentifier(p.name) && p.name.text === propName);
+			if (prop && typescript.isPropertyAssignment(prop)) return this.resolveToInitializer(prop.initializer) ?? prop.initializer;
+		}
+	}
+	extractPropertyTokenId(node) {
+		if (node.arguments.length < 2) throw new Error("useProperty requires two arguments: (Class, paramName)");
+		const classArg = node.arguments[0];
+		const nameArg = node.arguments[1];
+		if (!typescript.isIdentifier(classArg)) throw new Error("useProperty first argument must be a class identifier.");
+		if (!typescript.isStringLiteral(nameArg)) throw new Error("useProperty second argument must be a string literal.");
+		const className = classArg.text;
+		const paramName = nameArg.text;
+		return {
+			tokenId: `PropertyToken:${className}.${paramName}`,
+			className,
+			paramName
+		};
+	}
+	extractInterfaceTokenId(node) {
+		if (!node.typeArguments || node.typeArguments.length === 0) throw new Error("useInterface must have a type argument.");
+		const typeNode = node.typeArguments[0];
+		const symbol = this.checker.getTypeFromTypeNode(typeNode).getSymbol();
+		if (!symbol) return "AnonymousInterface";
+		const declarations = symbol.getDeclarations();
+		if (declarations && declarations.length > 0) return generateTokenId(symbol, declarations[0].getSourceFile());
+		return symbol.getName();
+	}
+	getTypeIdFromConstructor(type) {
+		const constructSignatures = type.getConstructSignatures();
+		let instanceType;
+		if (constructSignatures.length > 0) instanceType = constructSignatures[0].getReturnType();
+		else instanceType = type;
+		return this.getTypeId(instanceType);
+	}
+	extractScope(optionsNode) {
+		for (const prop of optionsNode.properties) if (typescript.isPropertyAssignment(prop) && typescript.isIdentifier(prop.name) && prop.name.text === "scope" && typescript.isStringLiteral(prop.initializer)) {
+			if (prop.initializer.text === "transient") return "transient";
+		}
+		return "singleton";
+	}
+	/**
+	* Resolves dependencies for all nodes in the graph.
+	* @param graph - The dependency graph.
+	*/
+	resolveAllDependencies(graph) {
+		for (const node of graph.nodes.values()) this.resolveDependencies(node, graph);
+	}
+	/**
+	* Resolves dependencies for a single service node by inspecting its constructor.
+	* @param node - The dependency node to resolve.
+	*/
+	resolveDependencies(node, graph) {
+		if (node.service.isFactory || node.service.type === "factory") return;
+		const symbol = node.service.implementationSymbol;
+		if (!symbol) return;
+		const declarations = symbol.getDeclarations();
+		if (!declarations || declarations.length === 0) return;
+		const classDecl = declarations.find((d) => typescript.isClassDeclaration(d));
+		if (!classDecl) return;
+		const className = classDecl.name?.getText() ?? "Anonymous";
+		const constructor = classDecl.members.find((m) => typescript.isConstructorDeclaration(m));
+		if (!constructor) return;
+		for (const param of constructor.parameters) {
+			const paramName = param.name.getText();
+			const typeNode = param.type;
+			if (!typeNode) continue;
+			const type = this.checker.getTypeFromTypeNode(typeNode);
+			const propertyTokenId = `PropertyToken:${className}.${paramName}`;
+			if (graph.nodes.has(propertyTokenId)) {
+				node.dependencies.push(propertyTokenId);
+				continue;
+			}
+			const depTokenId = this.getTypeId(type);
+			node.dependencies.push(depTokenId);
+		}
+	}
+	/**
+	* Generates a unique Token ID for a given Type.
+	* Uses file path hash + name for consistency and collision avoidance.
+	*
+	* @param type - The TypeScript Type.
+	* @returns A string identifier for the token.
+	*/
+	getTypeId(type) {
+		const symbol = type.getSymbol();
+		if (!symbol) return this.checker.typeToString(type);
+		const name = symbol.getName();
+		if (name === "__type" || name === "InterfaceToken" || name === "__brand") return this.checker.typeToString(type);
+		const declarations = symbol.getDeclarations();
+		if (declarations && declarations.length > 0) return generateTokenId(symbol, declarations[0].getSourceFile());
+		return symbol.getName();
+	}
+	/**
+	* Resolves a symbol, following aliases if necessary.
+	* @param symbol - The symbol to resolve.
+	* @returns The resolved symbol.
+	*/
+	resolveSymbol(symbol) {
+		if (symbol.flags & typescript.SymbolFlags.Alias) return this.resolveSymbol(this.checker.getAliasedSymbol(symbol));
+		return symbol;
+	}
+};
+
+//#endregion
+//#region ../core/src/generator/GraphValidator.ts
+/**
+* Validates the dependency graph for correctness.
+* Detects circular dependencies, missing bindings, and duplicates.
+*/
+var GraphValidator = class {
+	/**
+	* Validates the graph structure.
+	*
+	* @param graph - The dependency graph to validate.
+	* @throws {Error} If a circular dependency or missing binding is detected.
+	*/
+	validate(graph) {
+		const visited = /* @__PURE__ */ new Set();
+		const recursionStack = /* @__PURE__ */ new Set();
+		const parentTokens = graph.parentProvidedTokens ?? /* @__PURE__ */ new Set();
+		for (const [nodeId, node] of graph.nodes) if (parentTokens.has(nodeId)) {
+			if (node.service.isScoped) continue;
+			throw new Error(`Duplicate registration: '${nodeId}' is already registered in the parent container. Use 'scoped: true' to override the parent's registration intentionally.`);
+		}
+		for (const [nodeId, node] of graph.nodes) for (const depId of node.dependencies) {
+			const isProvidedLocally = graph.nodes.has(depId);
+			const isProvidedByParent = parentTokens.has(depId);
+			if (!isProvidedLocally && !isProvidedByParent) {
+				const serviceName = nodeId;
+				throw new Error(`Missing binding: Service '${serviceName}' depends on '${depId}', but no provider was registered.`);
+			}
+		}
+		for (const nodeId of graph.nodes.keys()) if (!visited.has(nodeId)) this.detectCycle(nodeId, graph, visited, recursionStack, parentTokens);
+	}
+	/**
+	* Recursive Helper for Cycle Detection (DFS).
+	*
+	* @param nodeId - The current node ID.
+	* @param graph - The graph.
+	* @param visited - Set of all visited nodes.
+	* @param stack - Set of nodes in the current recursion stack (path).
+	* @param parentTokens - Tokens from parent container (skip traversal).
+	*/
+	detectCycle(nodeId, graph, visited, stack, parentTokens) {
+		visited.add(nodeId);
+		stack.add(nodeId);
+		const node = graph.nodes.get(nodeId);
+		if (node) for (const depId of node.dependencies) {
+			if (parentTokens.has(depId)) continue;
+			if (!visited.has(depId)) this.detectCycle(depId, graph, visited, stack, parentTokens);
+			else if (stack.has(depId)) throw new Error(`Circular dependency detected: ${[...stack, depId].join(" -> ")}`);
+		}
+		stack.delete(nodeId);
+	}
+};
+
+//#endregion
+//#region src/index.ts
+/**
+* Initializes the TypeScript Language Service Plugin.
+*
+* This plugin wraps the standard TypeScript Language Service to provide
+* additional diagnostics for NeoSyringe usage (e.g., circular dependencies).
+*
+* @param modules - The typescript module passed by the tsserver.
+* @returns An object containing the `create` factory.
+*/
+function init(modules) {
+	const ts = modules.typescript;
+	/**
+	* Creates the proxy language service.
+	* @param info - Plugin configuration and context.
+	*/
+	function create(info) {
+		const proxy = Object.create(null);
+		for (const k of Object.keys(info.languageService)) {
+			const x = info.languageService[k];
+			proxy[k] = (...args) => x.apply(info.languageService, args);
+		}
+		/**
+		* Intercepts semantic diagnostics to add NeoSyringe validation errors.
+		* @param fileName - The file being analyzed.
+		*/
+		proxy.getSemanticDiagnostics = (fileName) => {
+			const prior = info.languageService.getSemanticDiagnostics(fileName);
+			const log = (msg) => {
+				if (info.project?.projectService?.logger) info.project.projectService.logger.info(`[NeoSyringe LSP] ${msg}`);
+			};
+			if (fileName.includes("container")) log(`Checking file: ${fileName}`);
+			try {
+				const program = info.languageService.getProgram();
+				if (!program) {
+					if (fileName.includes("container")) log(`No program available`);
+					return prior;
+				}
+				const sourceFile = program.getSourceFile(fileName);
+				if (!sourceFile) {
+					if (fileName.includes("container")) log(`No source file`);
+					return prior;
+				}
+				if (!sourceFile.getText().includes("defineBuilderConfig")) {
+					if (fileName.includes("container")) log(`No defineBuilderConfig found in file`);
+					return prior;
+				}
+				log(`Running analysis on: ${fileName}`);
+				const graph = new Analyzer(program).extract();
+				log(`Graph extracted with ${graph.nodes.size} nodes`);
+				const validator = new GraphValidator();
+				try {
+					validator.validate(graph);
+					log(`Validation passed`);
+				} catch (e) {
+					if (e instanceof Error) {
+						const msg = e.message;
+						log(`Validation error: ${msg}`);
+						prior.push({
+							file: sourceFile,
+							start: 0,
+							length: 10,
+							messageText: `[NeoSyringe] ${msg}`,
+							category: ts.DiagnosticCategory.Error,
+							code: 9999
+						});
+					}
+				}
+			} catch (e) {
+				if (e instanceof Error) {
+					log(`Analyzer exception: ${e.message}`);
+					if (e.message.includes("Duplicate")) {
+						const file = info.languageService.getProgram()?.getSourceFile(fileName);
+						if (file) {
+							log(`Adding duplicate diagnostic`);
+							prior.push({
+								file,
+								start: 0,
+								length: 10,
+								messageText: `[NeoSyringe] ${e.message}`,
+								category: ts.DiagnosticCategory.Error,
+								code: 9998
+							});
+						}
+					}
+				}
+			}
+			return prior;
+		};
+		return proxy;
+	}
+	return { create };
+}
+var src_default = init;
+
+//#endregion
+module.exports = src_default;

package/dist/index.d.cts

@@ -0,0 +1,18 @@
+import * as typescript0 from "typescript";
+
+//#region src/index.d.ts
+/**
+ * Initializes the TypeScript Language Service Plugin.
+ *
+ * This plugin wraps the standard TypeScript Language Service to provide
+ * additional diagnostics for NeoSyringe usage (e.g., circular dependencies).
+ *
+ * @param modules - The typescript module passed by the tsserver.
+ * @returns An object containing the `create` factory.
+ */
+declare function init(modules: {
+  typescript: typeof typescript0;
+}): {
+  create: (info: typescript0.server.PluginCreateInfo) => typescript0.LanguageService;
+};
+export = init;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@djodjonx/neosyringe-lsp",
+  "version": "0.0.1",
+  "description": "TypeScript Language Service Plugin for NeoSyringe",
+  "main": "dist/index.cjs",
+  "types": "dist/index.d.cts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.cts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@djodjonx/neosyringe-core": "0.1.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "devDependencies": {
+    "tsdown": "0.20.0-beta.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run"
+  }
+}