如何在VS Code IDE中增加一个用编程语言编写的具有运算模块的插件（一）

要在VS Code IDE中增加一个用编程语言编写的具有运算模块的插件，要实现插件的功能：

考虑扩展性设计： 8. 插件化架构：可随时添加新语言适配器； 9. 协议可扩展：支持自定义通信协议； 10. UI可定制：计算面板可配置主题和布局； 11. 功能可组合：不同语言的计算器可协同工作。

考虑通用实现模式的关键点： 12. 适配器模式：每种语言实现统一的接口; 13. 协议标准化：使用JSON、Protobuf等标准协议; 14. 通信多样化：支持进程、HTTP、WASM等多种通信方式; 15. 配置驱动：用户可配置计算引擎和参数; 16. 渐进增强：从简单到复杂逐步实现功能。

VS Code通用计算插件架构设计与实现

我将基于您的要求，设计一个高度可扩展的通用计算插件系统，逐一深入阐述每个方面。

一、需要具备的条件

1.1 技术前提条件

// 技术栈要求检查清单
interface Prerequisites {
// 1. 开发环境
node: '>=16.0.0',
npm: '>=8.0.0',
vscode: '>=1.75.0',

// 2. 语言运行时（根据需要）
python?: '>=3.8',
rust?: '>=1.60',
go?: '>=1.19',
java?: '>=11',

// 3. 构建工具
buildTools: {
typescript: '>=4.9',
webpack: '>=5.75',
wasmPack?: '>=0.10' // 如果支持WASM
},

// 4. 开发依赖
devDependencies: [
'@types/vscode',
'@types/node',
'typescript',
'eslint',
'webpack',
'vsce'
]
}

1.2 专业知识要求

• TypeScript/JavaScript：VS Code插件开发
• 目标语言：计算模块实现语言
• 进程间通信：IPC、RPC、HTTP等
• 协议设计：JSON-RPC、Protobuf、自定义协议
• 安全性：沙箱执行、输入验证、资源限制

二、VS Code IDE需要做的准备工作

2.1 环境配置

// .vscode/settings.json – 工作区配置
{
// 1. 启用插件开发模式
"extensions.autoUpdate": false,
"extensions.autoCheckUpdates": false,

// 2. 配置调试环境
"debug.javascript.usePreview": true,
"typescript.tsserver.maxTsServerMemory": 4096,

// 3. 计算插件特定配置
"files.associations": {
"*.calc": "json",
"*.math": "javascript"
},

// 4. 性能优化
"editor.codeActionsOnSave": {
"source.fixAll.eslint": true
},

// 5. 安全设置
"security.workspace.trust.enabled": true,
"security.workspace.trust.untrustedFiles": "open"
}

2.2 调试配置

// .vscode/launch.json – 调试配置
{
"version": "0.2.0",
"configurations": [
{
"name": "Run Extension",
"type": "extensionHost",
"request": "launch",
"args": [
"–extensionDevelopmentPath=${workspaceFolder}",
"–enable-proposed-api=${workspaceFolder}"
],
"outFiles": ["${workspaceFolder}/dist/**/*.js"],
"preLaunchTask": "${defaultBuildTask}"
},
{
"name": "Run Tests",
"type": "extensionHost",
"request": "launch",
"args": [
"–extensionDevelopmentPath=${workspaceFolder}",
"–extensionTestsPath=${workspaceFolder}/out/test/suite/index"
],
"outFiles": ["${workspaceFolder}/out/**/*.js"],
"preLaunchTask": "npm: compile-tests"
}
],
"compounds": [
{
"name": "Extension + Language Server",
"configurations": ["Run Extension", "Attach to Language Server"]
}
]
}

2.3 任务配置

// .vscode/tasks.json – 构建任务
{
"version": "2.0.0",
"tasks": [
{
"label": "Build All Engines",
"type": "shell",
"command": "npm run build:all",
"group": {
"kind": "build",
"isDefault": true
},
"presentation": {
"reveal": "always",
"panel": "shared"
}
},
{
"label": "Watch TypeScript",
"type": "typescript",
"tsconfig": "tsconfig.json",
"option": "watch",
"group": "build",
"problemMatcher": ["$tsc-watch"]
}
]
}

三、插件需要做的工作

3.1 核心架构实现

3.1.1 插件生命周期管理

// src/core/ExtensionLifecycle.ts
import * as vscode from 'vscode';
import { EventEmitter } from 'events';

export class ExtensionLifecycle extends EventEmitter {
private static instance: ExtensionLifecycle;
private isActive: boolean = false;
private dependencies: Map<string, boolean> = new Map();

private constructor(private context: vscode.ExtensionContext) {
super();
}

static getInstance(context?: vscode.ExtensionContext): ExtensionLifecycle {
if (!ExtensionLifecycle.instance && context) {
ExtensionLifecycle.instance = new ExtensionLifecycle(context);
}
return ExtensionLifecycle.instance;
}

async activate(): Promise<void> {
if (this.isActive) return;

try {
// 1. 检查依赖
await this.checkDependencies();

// 2. 初始化组件
await this.initializeComponents();

// 3. 注册功能
await this.registerFeatures();

this.isActive = true;
this.emit('activated');

vscode.window.setStatusBarMessage('计算插件已激活', 3000);

} catch (error) {
this.emit('activation-failed', error);
throw error;
}
}

private async checkDependencies(): Promise<void> {
const requiredDeps = [
{ name: 'node', version: '>=16.0.0' },
{ name: 'python', version: '>=3.8', optional: true },
{ name: 'rust', version: '>=1.60', optional: true },
{ name: 'go', version: '>=1.19', optional: true }
];

for (const dep of requiredDeps) {
const available = await this.checkRuntime(dep.name, dep.version);
this.dependencies.set(dep.name, available);

if (!available && !dep.optional) {
throw new Error(`必要依赖 ${dep.name} ${dep.version} 未找到`);
}
}
}

private async checkRuntime(name: string, version: string): Promise<boolean> {
const { exec } = require('child_process');

return new Promise((resolve) => {
exec(`${name} –version`, (error: Error | null, stdout: string) => {
if (error) {
resolve(false);
} else {
// 简单的版本检查
const match = stdout.match(/(\\d+\\.\\d+\\.\\d+)/);
if (match) {
resolve(this.compareVersions(match[1], version));
} else {
resolve(true);
}
}
});
});
}

private compareVersions(current: string, required: string): boolean {
// 简化的版本比较
return true; // 实际实现需要完整的版本比较逻辑
}

private async initializeComponents(): Promise<void> {
// 初始化各组件
const components = [
'LanguageManager',
'ProtocolManager',
'CalculatorRegistry',
'UIManager',
'SecurityManager'
];

for (const component of components) {
await this.initializeComponent(component);
}
}

private async initializeComponent(name: string): Promise<void> {
// 动态加载组件
try {
const module = await import(`../components/${name}`);
const instance = new module.default(this.context);
await instance.initialize();

this.context.subscriptions.push(instance);
this.emit('component-initialized', name, instance);
} catch (error) {
this.emit('component-failed', name, error);
}
}

private async registerFeatures(): Promise<void> {
// 注册插件功能
const features = [
{ type: 'command', id: 'calculator.evaluate' },
{ type: 'view', id: 'calculator.panel' },
{ type: 'provider', id: 'hover' },
{ type: 'provider', id: 'completion' },
{ type: 'editor', id: 'custom' }
];

for (const feature of features) {
await this.registerFeature(feature);
}
}

private async registerFeature(feature: any): Promise<void> {
// 注册特定功能
this.emit('feature-registered', feature);
}

async deactivate(): Promise<void> {
if (!this.isActive) return;

try {
// 1. 清理资源
await this.cleanupResources();

// 2. 终止计算引擎
await this.terminateEngines();

// 3. 保存状态
await this.persistState();

this.isActive = false;
this.emit('deactivated');

} catch (error) {
this.emit('deactivation-failed', error);
}
}

private async cleanupResources(): Promise<void> {
// 清理临时文件、关闭连接等
}

private async terminateEngines(): Promise<void> {
// 终止所有计算引擎
}

private async persistState(): Promise<void> {
// 保存插件状态
const state = {
dependencies: Object.fromEntries(this.dependencies),
lastActive: new Date().toISOString()
};

await this.context.globalState.update('pluginState', state);
}
}

3.1.2 语言管理器（支持插件化架构）

// src/core/LanguageManager.ts
import * as vscode from 'vscode';
import { EventEmitter } from 'events';

export interface LanguageAdapter {
readonly id: string;
readonly name: string;
readonly version: string;
readonly capabilities: string[];
readonly communicationProtocols: string[];

initialize(): Promise<void>;
evaluate(expression: string, context?: any): Promise<any>;
terminate(): Promise<void>;

// 生命周期事件
on(event: 'initialized', listener: () => void): this;
on(event: 'error', listener: (error: Error) => void): this;
on(event: 'result', listener: (result: any) => void): this;
}

export class LanguageManager extends EventEmitter {
private adapters: Map<string, LanguageAdapter> = new Map();
private adapterFactories: Map<string, AdapterFactory> = new Map();
private activeAdapter: string | null = null;

constructor(private context: vscode.ExtensionContext) {
super();
this.registerBuiltinAdapters();
this.loadExternalAdapters();
}

private registerBuiltinAdapters(): void {
// 注册内置适配器
const builtinAdapters = [
{ id: 'javascript', factory: JavaScriptAdapterFactory },
{ id: 'python', factory: PythonAdapterFactory },
{ id: 'rust', factory: RustAdapterFactory },
{ id: 'go', factory: GoAdapterFactory }
];

for (const adapter of builtinAdapters) {
this.registerAdapterFactory(adapter.id, adapter.factory);
}
}

private async loadExternalAdapters(): Promise<void> {
// 从配置文件加载外部适配器
const config = vscode.workspace.getConfiguration('universalCalculator');
const externalAdapters = config.get<any[]>('externalAdapters', []);

for (const adapterConfig of externalAdapters) {
try {
await this.loadExternalAdapter(adapterConfig);
} catch (error) {
vscode.window.showErrorMessage(
`加载外部适配器 ${adapterConfig.id} 失败: ${error}`
);
}
}
}

private async loadExternalAdapter(config: any): Promise<void> {
// 动态加载外部适配器模块
const modulePath = config.modulePath || `./adapters/${config.id}`;

try {
const module = await import(modulePath);
const factory = module.default || module;

if (typeof factory === 'function') {
this.registerAdapterFactory(config.id, factory);
this.emit('adapter-loaded', config.id);
}
} catch (error) {
throw new Error(`无法加载适配器模块: ${error}`);
}
}

registerAdapterFactory(id: string, factory: AdapterFactory): void {
this.adapterFactories.set(id, factory);
this.emit('factory-registered', id);
}

async createAdapter(id: string): Promise<LanguageAdapter> {
const factory = this.adapterFactories.get(id);
if (!factory) {
throw new Error(`未找到适配器工厂: ${id}`);
}

const adapter = factory(this.context);
await adapter.initialize();

this.adapters.set(id, adapter);
return adapter;
}

async getAdapter(id: string): Promise<LanguageAdapter> {
let adapter = this.adapters.get(id);

if (!adapter) {
adapter = await this.createAdapter(id);
}

return adapter;
}

async setActiveAdapter(id: string): Promise<void> {
if (this.activeAdapter === id) return;

const adapter = await this.getAdapter(id);
this.activeAdapter = id;

this.emit('active-adapter-changed', id, adapter);
vscode.window.showInformationMessage(`已切换到 ${adapter.name} 计算引擎`);
}

getActiveAdapter(): LanguageAdapter | null {
if (!this.activeAdapter) return null;
return this.adapters.get(this.activeAdapter) || null;
}

getAvailableAdapters(): string[] {
return Array.from(this.adapterFactories.keys());
}

getAdapterInfo(id: string): AdapterInfo | null {
const adapter = this.adapters.get(id);
if (!adapter) return null;

return {
id: adapter.id,
name: adapter.name,
version: adapter.version,
capabilities: adapter.capabilities,
protocols: adapter.communicationProtocols
};
}

async terminateAll(): Promise<void> {
for (const [id, adapter] of this.adapters) {
try {
await adapter.terminate();
this.emit('adapter-terminated', id);
} catch (error) {
this.emit('adapter-termination-failed', id, error);
}
}

this.adapters.clear();
this.activeAdapter = null;
}
}

3.2 协议管理系统（支持自定义协议）

// src/protocols/ProtocolManager.ts
export interface CommunicationProtocol {
readonly name: string;
readonly version: string;
readonly supportsBinary: boolean;
readonly supportsStreaming: boolean;

initialize(config: ProtocolConfig): Promise<void>;
send(request: ProtocolRequest): Promise<ProtocolResponse>;
receive(handler: (request: ProtocolRequest) => Promise<ProtocolResponse>): void;
terminate(): Promise<void>;
}

export interface ProtocolConfig {
type: 'stdio' | 'http' | 'websocket' | 'grpc' | 'wasm' | 'custom';
endpoint?: string;
port?: number;
options?: Record<string, any>;
}

export class ProtocolManager {
private protocols: Map<string, CommunicationProtocol> = new Map();
private protocolFactories: Map<string, ProtocolFactory> = new Map();
private activeProtocols: Map<string, string> = new Map(); // adapterId -> protocolName

constructor() {
this.registerBuiltinProtocols();
}

private registerBuiltinProtocols(): void {
// 注册内置协议
const builtinProtocols = [
{ name: 'stdio', factory: StdioProtocolFactory },
{ name: 'http-rest', factory: HttpRestProtocolFactory },
{ name: 'websocket', factory: WebSocketProtocolFactory },
{ name: 'grpc', factory: GrpcProtocolFactory },
{ name: 'wasm', factory: WasmProtocolFactory }
];

for (const protocol of builtinProtocols) {
this.registerProtocolFactory(protocol.name, protocol.factory);
}
}

registerProtocolFactory(name: string, factory: ProtocolFactory): void {
this.protocolFactories.set(name, factory);
}

async createProtocol(name: string, config: ProtocolConfig): Promise<CommunicationProtocol> {
const factory = this.protocolFactories.get(name);
if (!factory) {
throw new Error(`未找到协议工厂: ${name}`);
}

const protocol = factory();
await protocol.initialize(config);

this.protocols.set(this.getProtocolKey(name, config), protocol);
return protocol;
}

private getProtocolKey(name: string, config: ProtocolConfig): string {
return `${name}:${JSON.stringify(config)}`;
}

async bindProtocolToAdapter(
adapterId: string,
protocolName: string,
config: ProtocolConfig
): Promise<void> {
const protocol = await this.createProtocol(protocolName, config);
this.activeProtocols.set(adapterId, this.getProtocolKey(protocolName, config));

// 设置协议消息处理器
protocol.receive(async (request) => {
return await this.handleProtocolRequest(adapterId, request);
});
}

private async handleProtocolRequest(
adapterId: string,
request: ProtocolRequest
): Promise<ProtocolResponse> {
try {
// 将协议请求转换为计算请求
const calculationRequest = this.parseRequest(request);

// 获取对应的适配器
const adapter = await languageManager.getAdapter(adapterId);
const result = await adapter.evaluate(
calculationRequest.expression,
calculationRequest.context
);

// 将计算结果转换为协议响应
return this.createResponse(request.id, result);
} catch (error) {
return this.createErrorResponse(request.id, error);
}
}

private parseRequest(request: ProtocolRequest): CalculationRequest {
// 根据协议类型解析请求
switch (request.protocol) {
case 'json-rpc':
return this.parseJsonRpcRequest(request);
case 'protobuf':
return this.parseProtobufRequest(request);
case 'custom':
return this.parseCustomRequest(request);
default:
throw new Error(`不支持的协议: ${request.protocol}`);
}
}

private parseJsonRpcRequest(request: ProtocolRequest): CalculationRequest {
const data = JSON.parse(request.data.toString());
return {
expression: data.params.expression,
context: data.params.context
};
}

private createResponse(requestId: string, result: any): ProtocolResponse {
return {
id: requestId,
status: 'success',
data: Buffer.from(JSON.stringify({ result })),
metadata: {
timestamp: new Date().toISOString(),
protocol: 'json-rpc'
}
};
}

getAvailableProtocols(): ProtocolInfo[] {
return Array.from(this.protocolFactories.keys()).map(name => ({
name,
supportsBinary: this.getProtocolFactory(name)?.supportsBinary || false,
supportsStreaming: this.getProtocolFactory(name)?.supportsStreaming || false
}));
}

private getProtocolFactory(name: string): ProtocolFactory | undefined {
return this.protocolFactories.get(name);
}
}

3.3 计算器注册表（支持功能组合）

// src/core/CalculatorRegistry.ts
export interface CalculatorCapability {
id: string;
name: string;
description: string;
inputTypes: string[];
outputTypes: string[];
parameters: ParameterDefinition[];
}

export interface CalculatorInstance {
id: string;
adapterId: string;
capabilityId: string;
configuration: Record<string, any>;
status: 'idle' | 'busy' | 'error';
lastUsed: Date;
}

export class CalculatorRegistry {
private capabilities: Map<string, CalculatorCapability> = new Map();
private instances: Map<string, CalculatorInstance> = new Map();
private workflows: Map<string, CalculatorWorkflow> = new Map();

constructor(private languageManager: LanguageManager) {
this.registerBuiltinCapabilities();
}

private registerBuiltinCapabilities(): void {
const builtinCapabilities: CalculatorCapability[] = [
{
id: 'basic-arithmetic',
name: '基础算术',
description: '支持加减乘除、幂运算等基础算术操作',
inputTypes: ['number', 'string'],
outputTypes: ['number'],
parameters: [
{ name: 'precision', type: 'number', default: 10 },
{ name: 'format', type: 'string', default: 'decimal' }
]
},
{
id: 'matrix-operations',
name: '矩阵运算',
description: '矩阵乘法、求逆、特征值等运算',
inputTypes: ['matrix', 'array'],
outputTypes: ['matrix', 'array'],
parameters: [
{ name: 'algorithm', type: 'string', default: 'default' }
]
},
{
id: 'statistical-analysis',
name: '统计分析',
description: '均值、方差、标准差等统计计算',
inputTypes: ['array'],
outputTypes: ['object'],
parameters: [
{ name: 'confidence', type: 'number', default: 0.95 }
]
},
{
id: 'symbolic-computation',
name: '符号计算',
description: '代数运算、微积分、方程求解',
inputTypes: ['string'],
outputTypes: ['string', 'expression'],
parameters: [
{ name: 'simplify', type: 'boolean', default: true }
]
}
];

for (const capability of builtinCapabilities) {
this.registerCapability(capability);
}
}

registerCapability(capability: CalculatorCapability): void {
this.capabilities.set(capability.id, capability);
}

async createInstance(
adapterId: string,
capabilityId: string,
configuration: Record<string, any> = {}
): Promise<CalculatorInstance> {
// 检查适配器是否支持该能力
const adapter = await this.languageManager.getAdapter(adapterId);
const capability = this.capabilities.get(capabilityId);

if (!capability) {
throw new Error(`未知的计算能力: ${capabilityId}`);
}

// 验证适配器能力
if (!adapter.capabilities.includes(capabilityId)) {
throw new Error(`适配器 ${adapterId} 不支持能力 ${capabilityId}`);
}

const instance: CalculatorInstance = {
id: this.generateInstanceId(),
adapterId,
capabilityId,
configuration,
status: 'idle',
lastUsed: new Date()
};

this.instances.set(instance.id, instance);
return instance;
}

async execute(
instanceId: string,
input: any,
context?: any
): Promise<any> {
const instance = this.instances.get(instanceId);
if (!instance) {
throw new Error(`计算实例不存在: ${instanceId}`);
}

instance.status = 'busy';

try {
const adapter = await this.languageManager.getAdapter(instance.adapterId);
const capability = this.capabilities.get(instance.capabilityId)!;

// 准备执行上下文
const executionContext = {
…context,
configuration: instance.configuration,
capability: capability
};

// 构建执行表达式
const expression = this.buildExpression(capability, input, executionContext);

// 执行计算
const result = await adapter.evaluate(expression, executionContext);

instance.status = 'idle';
instance.lastUsed = new Date();

return result;
} catch (error) {
instance.status = 'error';
throw error;
}
}

private buildExpression(
capability: CalculatorCapability,
input: any,
context: any
): string {
// 根据能力类型构建表达式
switch (capability.id) {
case 'basic-arithmetic':
return this.buildArithmeticExpression(input, context);
case 'matrix-operations':
return this.buildMatrixExpression(input, context);
case 'statistical-analysis':
return this.buildStatisticsExpression(input, context);
case 'symbolic-computation':
return this.buildSymbolicExpression(input, context);
default:
return String(input);
}
}

private buildArithmeticExpression(input: string, context: any): string {
// 简化的算术表达式构建
return input;
}

// 创建工作流（功能组合）
async createWorkflow(
name: string,
steps: WorkflowStep[]
): Promise<CalculatorWorkflow> {
const workflow: CalculatorWorkflow = {
id: this.generateWorkflowId(),
name,
steps,
status: 'idle',
createdAt: new Date()
};

this.workflows.set(workflow.id, workflow);
return workflow;
}

async executeWorkflow(workflowId: string, initialInput: any): Promise<any> {
const workflow = this.workflows.get(workflowId);
if (!workflow) {
throw new Error(`工作流不存在: ${workflowId}`);
}

workflow.status = 'running';

let currentResult = initialInput;

for (const step of workflow.steps) {
try {
currentResult = await this.execute(
step.instanceId,
currentResult,
step.context
);

// 检查是否需要中止
if (step.condition && !this.evaluateCondition(step.condition, currentResult)) {
break;
}
} catch (error) {
workflow.status = 'error';
throw new Error(`工作流步骤执行失败: ${step.instanceId}, 错误: ${error}`);
}
}

workflow.status = 'completed';
return currentResult;
}

private evaluateCondition(condition: string, result: any): boolean {
// 简化的条件评估
try {
return eval(condition);
} catch {
return false;
}
}

private generateInstanceId(): string {
return `calc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
}

private generateWorkflowId(): string {
return `workflow_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
}
}

四、项目结构设计

4.1 完整的项目结构

universal-calculator-extension/
├── .vscode/ # VS Code配置文件
│ ├── launch.json # 调试配置
│ ├── tasks.json # 任务配置
│ ├── settings.json # 工作区设置
│ └── extensions.json # 推荐扩展
│
├── src/ # 源代码
│ ├── core/ # 核心架构
│ │ ├── ExtensionLifecycle.ts # 插件生命周期
│ │ ├── LanguageManager.ts # 语言管理器
│ │ ├── CalculatorRegistry.ts # 计算器注册表
│ │ └── SecurityManager.ts # 安全管理器
│ │
│ ├── adapters/ # 语言适配器
│ │ ├── base/ # 适配器基类
│ │ │ ├── BaseAdapter.ts # 基础适配器
│ │ │ ├── StdioAdapter.ts # 进程通信适配器
│ │ │ ├── HttpAdapter.ts # HTTP通信适配器
│ │ │ └── WasmAdapter.ts # WASM适配器
│ │ │
│ │ ├── builtin/ # 内置适配器
│ │ │ ├── JavaScriptAdapter.ts
│ │ │ ├── PythonAdapter.ts
│ │ │ ├── RustAdapter.ts
│ │ │ └── GoAdapter.ts
│ │ │
│ │ └── external/ # 外部适配器加载器
│ │ └── ExternalAdapterLoader.ts
│ │
│ ├── protocols/ # 通信协议
│ │ ├── ProtocolManager.ts # 协议管理器
│ │ ├── base/ # 协议基类
│ │ │ ├── BaseProtocol.ts
│ │ │ └── ProtocolFactory.ts
│ │ │
│ │ ├── implementations/ # 协议实现
│ │ │ ├── JsonRpcProtocol.ts
│ │ │ ├── ProtobufProtocol.ts
│ │ │ ├── StdioProtocol.ts
│ │ │ ├── WebSocketProtocol.ts
│ │ │ └── CustomProtocol.ts
│ │ │
│ │ └── schemas/ # 协议模式
│ │ ├── calculator.proto # Protobuf定义
│ │ ├── rpc.schema.json # JSON Schema
│ │ └── types.ts # TypeScript类型
│ │
│ ├── ui/ # 用户界面
│ │ ├── components/ # UI组件
│ │ │ ├── CalculatorPanel.ts
│ │ │ ├── HistoryView.ts
│ │ │ ├── VariableManager.ts
│ │ │ └── ThemeManager.ts # 主题管理器
│ │ │
│ │ ├── views/ # 视图提供者
│ │ │ ├── CalculatorViewProvider.ts
│ │ │ └── HistoryViewProvider.ts
│ │ │
│ │ └── webviews/ # Webview实现
│ │ ├── CalculatorWebview.ts
│ │ └── NotebookWebview.ts
│ │
│ ├── providers/ # VS Code提供者
│ │ ├── HoverProvider.ts
│ │ ├── CompletionProvider.ts
│ │ ├── CodeActionProvider.ts
│ │ └── DocumentSymbolProvider.ts
│ │
│ ├── commands/ # 命令实现
│ │ ├── CalculateCommand.ts
│ │ ├── OpenPanelCommand.ts
│ │ ├── ManageAdaptersCommand.ts
│ │ └── ExecuteWorkflowCommand.ts
│ │
│ ├── utils/ # 工具函数
│ │ ├── ValidationUtils.ts
│ │ ├── SecurityUtils.ts
│ │ ├── PerformanceUtils.ts
│ │ └── Logger.ts
│ │
│ ├── types/ # 类型定义
│ │ ├── calculator.ts
│ │ ├── protocol.ts
│ │ └── ui.ts
│ │
│ └── extension.ts # 插件主入口
│
├── engines/ # 计算引擎实现
│ ├── shared/ # 共享代码
│ │ ├── protocol/ # 协议定义
│ │ └── utils/ # 工具函数
│ │
│ ├── python/ # Python引擎
│ │ ├── src/
│ │ │ ├── calculator.py # 计算器实现
│ │ │ ├── server.py # HTTP服务器
│ │ │ └── stdio_handler.py # 标准I/O处理器
│ │ ├── requirements.txt # Python依赖
│ │ └── pyproject.toml # 项目配置
│ │
│ ├── rust/ # Rust引擎
│ │ ├── src/
│ │ │ ├── lib.rs # 库实现
│ │ │ ├── calculator.rs # 计算逻辑
│ │ │ └── server.rs # 服务器实现
│ │ ├── Cargo.toml # Rust配置
│ │ └── build.rs # 构建脚本
│ │
│ └── go/ # Go引擎
│ ├── src/
│ │ ├── main.go # 主入口
│ │ ├── calculator/ # 计算包
│ │ └── server/ # 服务器包
│ ├── go.mod # Go模块
│ └── go.sum # 依赖锁
│
├── resources/ # 静态资源
│ ├── views/ # Webview页面
│ │ ├── calculator.html
│ │ ├── notebook.html
│ │ └── panel.html
│ │
│ ├── themes/ # UI主题
│ │ ├── light.css
│ │ ├── dark.css
│ │ └── custom.css
│ │
│ ├── icons/ # 图标资源
│ │ ├── calculator.svg
│ │ ├── python.svg
│ │ └── rust.svg
│ │
│ └── snippets/ # 代码片段
│ ├── javascript.json
│ ├── python.json
│ └── math.json
│
├── test/ # 测试文件
│ ├── unit/ # 单元测试
│ ├── integration/ # 集成测试
│ └── e2e/ # 端到端测试
│
├── dist/ # 编译输出
├── out/ # TypeScript输出
│
├── package.json # 插件清单
├── tsconfig.json # TypeScript配置
├── webpack.config.js # Webpack配置
├── .eslintrc.json # ESLint配置
├── .prettierrc # Prettier配置
├── CHANGELOG.md # 更新日志
└── README.md # 说明文档

4.2 最小化必需文件结构

对于最小可工作版本：
1. package.json # 插件配置清单
2. src/extension.ts # 插件主入口
3. src/adapters/JavaScriptAdapter.ts # 至少一个适配器
4. src/ui/CalculatorPanel.ts # 用户界面
5. resources/calculator.html # Webview页面
6. tsconfig.json # TypeScript配置
7. README.md # 使用说明

五、必需文件详解

5.1 package.json（插件清单）

{
"name": "universal-calculator",
"displayName": "Universal Calculator",
"version": "1.0.0",
"publisher": "your-company",
"description": "A universal calculator plugin supporting multiple programming languages",
"keywords": ["calculator", "math", "compute", "multi-language"],
"categories": ["Other", "Programming Languages", "Snippets"],
"icon": "resources/icon.png",
"galleryBanner": {
"color": "#0052CC",
"theme": "dark"
},
"engines": {
"vscode": "^1.75.0"
},
"activationEvents": [
"onStartupFinished",
"onCommand:universalCalculator.calculate",
"onLanguage:javascript",
"onLanguage:python",
"onLanguage:typescript"
],
"main": "./dist/extension.js",
"browser": "./dist/web/extension.js",
"contributes": {
"commands": [
{
"command": "universalCalculator.calculate",
"title": "Calculate Expression",
"category": "Universal Calculator"
},
{
"command": "universalCalculator.openPanel",
"title": "Open Calculator Panel"
},
{
"command": "universalCalculator.manageAdapters",
"title": "Manage Language Adapters"
}
],
"menus": {
"editor/context": [
{
"command": "universalCalculator.calculate",
"when": "editorHasSelection",
"group": "navigation"
}
],
"commandPalette": [
{
"command": "universalCalculator.calculate",
"when": "editorTextFocus"
}
]
},
"views": {
"explorer": [
{
"id": "universalCalculator.view",
"name": "Calculator",
"when": "universalCalculator.enabled"
}
]
},
"viewsContainers": {
"activitybar": [
{
"id": "universal-calculator",
"title": "Calculator",
"icon": "resources/calculator.svg"
}
]
},
"configuration": {
"title": "Universal Calculator",
"properties": {
"universalCalculator.enable": {
"type": "boolean",
"default": true,
"description": "Enable the universal calculator"
},
"universalCalculator.defaultLanguage": {
"type": "string",
"enum": ["javascript", "python", "rust", "go"],
"default": "javascript",
"description": "Default calculation language"
},
"universalCalculator.autoEvaluate": {
"type": "boolean",
"default": false,
"description": "Automatically evaluate expressions"
},
"universalCalculator.protocol": {
"type": "string",
"enum": ["stdio", "http", "websocket", "wasm"],
"default": "stdio",
"description": "Communication protocol for external engines"
},
"universalCalculator.externalAdapters": {
"type": "array",
"default": [],
"description": "External language adapters configuration"
},
"universalCalculator.theme": {
"type": "string",
"enum": ["light", "dark", "system", "custom"],
"default": "system",
"description": "UI theme for calculator"
}
}
},
"snippets": [
{
"language": "*",
"path": "./resources/snippets/math.json"
}
]
},
"scripts": {
"vscode:prepublish": "npm run package",
"compile": "webpack –mode production",
"watch": "webpack –mode development –watch",
"package": "webpack –mode production && vsce package",
"compile-tests": "tsc -p . –outDir out",
"watch-tests": "tsc -p . -w –outDir out",
"pretest": "npm run compile-tests && npm run lint",
"lint": "eslint src –ext ts",
"test": "node ./out/test/runTest.js",
"build:engines": "node scripts/build-engines.js",
"dev": "concurrently \\"npm run watch\\" \\"npm run build:engines — –watch\\""
},
"dependencies": {
"axios": "^1.3.0",
"ws": "^8.12.0",
"protobufjs": "^7.2.0",
"mathjs": "^11.5.0",
"decimal.js": "^10.4.0",
"lodash": "^4.17.21",
"uuid": "^9.0.0"
},
"devDependencies": {
"@types/vscode": "^1.75.0",
"@types/node": "^18.0.0",
"@types/ws": "^8.5.4",
"typescript": "^4.9.0",
"webpack": "^5.75.0",
"webpack-cli": "^5.0.0",
"ts-loader": "^9.4.0",
"eslint": "^8.0.0",
"@typescript-eslint/eslint-plugin": "^5.0.0",
"@typescript-eslint/parser": "^5.0.0",
"vsce": "^2.0.0",
"concurrently": "^7.6.0"
},
"extensionDependencies": [],
"capabilities": {
"untrustedWorkspaces": {
"supported": true,
"description": "Calculator works in untrusted workspaces"
},
"virtualWorkspaces": {
"supported": true,
"description": "Calculator works in virtual workspaces"
}
}
}

5.2 插件主入口（extension.ts）

import * as vscode from 'vscode';
import { ExtensionLifecycle } from './core/ExtensionLifecycle';
import { LanguageManager } from './core/LanguageManager';
import { CalculatorRegistry } from './core/CalculatorRegistry';
import { ProtocolManager } from './protocols/ProtocolManager';
import { UIManager } from './ui/UIManager';

// 单例管理器
let lifecycle: ExtensionLifecycle;
let languageManager: LanguageManager;
let calculatorRegistry: CalculatorRegistry;
let protocolManager: ProtocolManager;
let uiManager: UIManager;

export async function activate(context: vscode.ExtensionContext) {
console.log('Universal Calculator extension is now active!');

try {
// 1. 初始化生命周期管理器
lifecycle = ExtensionLifecycle.getInstance(context);

// 2. 初始化核心组件
languageManager = new LanguageManager(context);
calculatorRegistry = new CalculatorRegistry(languageManager);
protocolManager = new ProtocolManager();
uiManager = new UIManager(context);

// 3. 注册到订阅
context.subscriptions.push(
lifecycle,
languageManager,
calculatorRegistry,
protocolManager,
uiManager
);

// 4. 激活插件
await lifecycle.activate();

// 5. 设置初始状态
await initializeDefaultState(context);

vscode.window.showInformationMessage(
'Universal Calculator 已成功激活！',
'查看教程', '打开面板'
).then(selection => {
if (selection === '查看教程') {
vscode.commands.executeCommand('markdown.showPreview',
vscode.Uri.joinPath(context.extensionUri, 'TUTORIAL.md'));
} else if (selection === '打开面板') {
vscode.commands.executeCommand('universalCalculator.openPanel');
}
});

} catch (error) {
vscode.window.showErrorMessage(
`插件激活失败: ${error.message}`,
'查看日志', '重新加载'
).then(selection => {
if (selection === '查看日志') {
vscode.commands.executeCommand('workbench.action.output.toggleOutput');
} else if (selection === '重新加载') {
vscode.commands.executeCommand('workbench.action.reloadWindow');
}
});
}
}

export async function deactivate() {
console.log('Universal Calculator extension is deactivating…');

try {
if (lifecycle) {
await lifecycle.deactivate();
}

// 清理资源
if (calculatorRegistry) {
await calculatorRegistry.terminateAll();
}

if (languageManager) {
await languageManager.terminateAll();
}

console.log('Universal Calculator extension has been deactivated.');
} catch (error) {
console.error('Deactivation failed:', error);
}
}

async function initializeDefaultState(context: vscode.ExtensionContext) {
// 从配置获取默认语言
const config = vscode.workspace.getConfiguration('universalCalculator');
const defaultLanguage = config.get<string>('defaultLanguage', 'javascript');

try {
// 设置默认语言适配器
await languageManager.setActiveAdapter(defaultLanguage);

// 创建默认计算实例
await calculatorRegistry.createInstance(
defaultLanguage,
'basic-arithmetic',
{ precision: 10 }
);

// 初始化UI
await uiManager.initialize();

// 保存初始状态
await context.globalState.update('initialized', true);
await context.globalState.update('initializationTime', new Date().toISOString());

} catch (error) {
vscode.window.showWarningMessage(
`默认设置初始化失败: ${error.message}`
);
}
}

// 导出API供其他扩展使用
export const api = {
getLanguageManager: () => languageManager,
getCalculatorRegistry: () => calculatorRegistry,
getProtocolManager: () => protocolManager,
evaluate: async (expression: string, language?: string) => {
const lang = language ||
vscode.workspace.getConfiguration('universalCalculator')
.get<string>('defaultLanguage', 'javascript');

const adapter = await languageManager.getAdapter(lang);
return adapter.evaluate(expression);
}
};

六、VS Code如何使用插件

6.1 安装与配置

// 用户配置示例 (.vscode/settings.json)
{
// 启用插件
"universalCalculator.enable": true,

// 设置默认计算语言
"universalCalculator.defaultLanguage": "python",

// 配置Python路径（如果需要）
"universalCalculator.pythonPath": "/usr/bin/python3",

// 启用自动计算
"universalCalculator.autoEvaluate": true,

// 设置通信协议
"universalCalculator.protocol": "http",

// 自定义适配器
"universalCalculator.externalAdapters": [
{
"id": "julia",
"name": "Julia Calculator",
"modulePath": "./.vscode/julia-adapter.js",
"config": {
"juliaPath": "/usr/local/bin/julia",
"port": 9090
}
}
],

// UI主题设置
"universalCalculator.theme": "dark",

// 工作流配置
"universalCalculator.workflows": {
"data-analysis": [
{
"language": "python",
"expression": "import numpy as np; np.mean(data)"
},
{
"language": "rust",
"expression": "statistical_analysis(data)"
}
]
}
}

6.2 使用方式示例

方式1：命令面板（Ctrl+Shift+P）

// 用户操作流程：
1. 打开命令面板 (Ctrl+Shift+P)
2. 输入 "Calculate Expression"
3. 输入表达式: "2 * (3 + 4)^2"
4. 选择计算语言: Python
5. 查看结果: 98

// 或使用快捷键：
1. 选中表达式
2. 按 Ctrl+Shift+C
3. 自动计算并显示结果

方式2：右键菜单

# 在Python文件中
import numpy as np

# 选中下面的表达式，右键选择"Calculate"
data = [1, 2, 3, 4, 5]
mean_value = np.mean(data) # 右键计算 → 3.0
std_value = np.std(data) # 右键计算 → 1.414…

方式3：内联计算注释

// 使用特殊注释触发计算
//= 2 * Math.PI * 5 // 自动计算 → 31.4159

// 多行计算
/*=
matrix_a = [[1, 2], [3, 4]]
matrix_b = [[5, 6], [7, 8]]
result = np.dot(matrix_a, matrix_b)
*/ // 自动计算 → [[19, 22], [43, 50]]

方式4：计算笔记本

# 创建 .calc 文件
创建新文件 → 保存为 analysis.calc

## 数据导入
```python
data = [23, 45, 67, 89, 12, 34, 56, 78]

统计分析

// 计算统计量
const stats = statisticalAnalysis(data)
// mean: 50.5, std: 25.8, min: 12, max: 89

可视化

# 生成图表
plt.plot(data)
plt.title("Data Distribution")

#### 方式5：工作流执行
```typescript
// 定义复杂计算工作流
const workflow = {
name: "Financial Analysis",
steps: [
{
language: "python",
expression: "fetch_stock_data('AAPL', '2023-01-01', '2023-12-31')",
output: "stock_data"
},
{
language: "rust",
expression: "calculate_returns(stock_data)",
output: "returns"
},
{
language: "javascript",
expression: "calculate_volatility(returns)",
output: "volatility"
},
{
language: "python",
expression: "plot_results(returns, volatility)",
output: "chart"
}
]
};

// 执行工作流
await calculatorRegistry.executeWorkflow(workflow);

七、插件如何扩展VS Code功能

7.1 扩展点实现

7.1.1 自定义编辑器

// src/ui/NotebookEditor.ts
export class CalculatorNotebookEditor implements vscode.CustomTextEditorProvider {

async resolveCustomTextEditor(
document: vscode.TextDocument,
webviewPanel: vscode.WebviewPanel
): Promise<void> {

webviewPanel.webview.options = {
enableScripts: true,
localResourceRoots: [this.context.extensionUri]
};

webviewPanel.webview.html = this.getNotebookHtml(webviewPanel.webview);

// 处理单元格操作
webviewPanel.webview.onDidReceiveMessage(async message => {
switch (message.type) {
case 'evaluateCell':
await this.evaluateCell(message.cellId, message.content);
break;
case 'addCell':
await this.addCell(message.cellType);
break;
case 'changeLanguage':
await this.changeCellLanguage(message.cellId, message.language);
break;
case 'saveNotebook':
await this.saveNotebook(document);
break;
}
});

// 更新文档内容
const changeDocumentSubscription = vscode.workspace.onDidChangeTextDocument(e => {
if (e.document.uri.toString() === document.uri.toString()) {
this.updateWebview(webviewPanel.webview, document);
}
});

webviewPanel.onDidDispose(() => {
changeDocumentSubscription.dispose();
});

this.updateWebview(webviewPanel.webview, document);
}

private getNotebookHtml(webview: vscode.Webview): string {
const scriptUri = webview.asWebviewUri(
vscode.Uri.joinPath(this.context.extensionUri, 'resources', 'notebook.js')
);

const styleUri = webview.asWebviewUri(
vscode.Uri.joinPath(this.context.extensionUri, 'resources', 'themes', 'notebook.css')
);

return `
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link href="${styleUri}" rel="stylesheet">
<title>Calculation Notebook</title>
</head>
<body>
<div id="notebook-container">
<div class="toolbar">
<button onclick="addCell('code')">+ Code Cell</button>
<button onclick="addCell('markdown')">+ Markdown</button>
<select id="language-selector">
<option value="python">Python</option>
<option value="javascript">JavaScript</option>
<option value="rust">Rust</option>
</select>
<button onclick="runAllCells()">Run All</button>
</div>
<div id="cells-container"></div>
</div>
<script src="${scriptUri}"></script>
</body>
</html>`;
}
}

7.1.2 语言智能感知

// src/providers/CompletionProvider.ts
export class CalculatorCompletionProvider implements vscode.CompletionItemProvider {

provideCompletionItems(
document: vscode.TextDocument,
position: vscode.Position,
token: vscode.CancellationToken,
context: vscode.CompletionContext
): vscode.ProviderResult<vscode.CompletionItem[] | vscode.CompletionList> {

const line = document.lineAt(position.line);
const linePrefix = line.text.substring(0, position.character);

// 检测是否需要提供计算补全
if (this.shouldProvideCompletions(linePrefix, document.languageId)) {
return this.getCalculatorCompletions(document.languageId);
}

return [];
}

private shouldProvideCompletions(linePrefix: string, languageId: string): boolean {
// 触发条件
const triggers = {
'python': ['#=', 'np.', 'math.', 'pd.'],
'javascript': ['//=', 'Math.', 'calc.'],
'typescript': ['//=', 'Math.', 'calc.'],
'*': ['='] // 通用触发
};

const languageTriggers = triggers[languageId as keyof typeof triggers] || triggers['*'];
return languageTriggers.some(trigger => linePrefix.includes(trigger));
}

private getCalculatorCompletions(languageId: string): vscode.CompletionItem[] {
const completions: vscode.CompletionItem[] = [];

// 通用数学函数
const mathFunctions = [
{ label: 'sin', detail: 'Sine function', insertText: 'sin($1)' },
{ label: 'cos', detail: 'Cosine function', insertText: 'cos($1)' },
{ label: 'tan', detail: 'Tangent function', insertText: 'tan($1)' },
{ label: 'sqrt', detail: 'Square root', insertText: 'sqrt($1)' },
{ label: 'log', detail: 'Logarithm', insertText: 'log($1)' },
{ label: 'exp', detail: 'Exponential', insertText: 'exp($1)' },
];

mathFunctions.forEach(func => {
const item = new vscode.CompletionItem(
func.label,
vscode.CompletionItemKind.Function
);
item.detail = func.detail;
item.insertText = new vscode.SnippetString(func.insertText);
item.documentation = new vscode.MarkdownString(`**${func.label}**\\n\\n数学函数`);
completions.push(item);
});

// 语言特定函数
const languageSpecific = this.getLanguageSpecificCompletions(languageId);
completions.push(…languageSpecific);

// 计算器命令
const commands = [
{ label: 'calculate', detail: 'Calculate expression', insertText: '//= ${1:expression}' },
{ label: 'stats', detail: 'Statistical analysis', insertText: '//stats ${1:data}' },
{ label: 'plot', detail: 'Create plot', insertText: '//plot ${1:x}, ${2:y}' },
];

commands.forEach(cmd => {
const item = new vscode.CompletionItem(
cmd.label,
vscode.CompletionItemKind.Snippet
);
item.detail = cmd.detail;
item.insertText = new vscode.SnippetString(cmd.insertText);
completions.push(item);
});

return completions;
}
}

7.1.3 代码操作

// src/providers/CodeActionProvider.ts
export class CalculatorCodeActionProvider implements vscode.CodeActionProvider {

provideCodeActions(
document: vscode.TextDocument,
range: vscode.Range | vscode.Selection,
context: vscode.CodeActionContext,
token: vscode.CancellationToken
): vscode.ProviderResult<(vscode.Command | vscode.CodeAction)[]> {

const actions: vscode.CodeAction[] = [];

// 1. 计算选中表达式
if (!range.isEmpty) {
const selectedText = document.getText(range);
if (this.looksLikeExpression(selectedText)) {
const calculateAction = new vscode.CodeAction(
'Calculate Expression',
vscode.CodeActionKind.QuickFix
);
calculateAction.command = {
command: 'universalCalculator.calculate',
title: 'Calculate',
arguments: [selectedText]
};
actions.push(calculateAction);
}
}

// 2. 转换数学符号
const line = document.lineAt(range.start.line);
const convertAction = this.provideConvertAction(line.text, range);
if (convertAction) {
actions.push(convertAction);
}

// 3. 提取为变量
const extractAction = this.provideExtractAction(document, range);
if (extractAction) {
actions.push(extractAction);
}

return actions;
}

private looksLikeExpression(text: string): boolean {
// 简单的表达式检测
const expressionPatterns = [
/^\\d+[\\s\\S]*[\\+\\-\\*\\/\\^]\\d+/,
/^Math\\./,
/^np\\./,
/^sqrt\\(/,
/^sum\\(/,
/^mean\\(/
];

return expressionPatterns.some(pattern => pattern.test(text.trim()));
}
}

7.2 视图容器扩展

// src/ui/views/CalculatorViewProvider.ts
export class CalculatorViewProvider implements vscode.TreeDataProvider<CalculatorViewItem> {

private _onDidChangeTreeData = new vscode.EventEmitter<CalculatorViewItem | undefined>();
readonly onDidChangeTreeData = this._onDidChangeTreeData.event;

constructor(
private context: vscode.ExtensionContext,
private languageManager: LanguageManager,
private calculatorRegistry: CalculatorRegistry
) {}

getTreeItem(element: CalculatorViewItem): vscode.TreeItem {
return element;
}

getChildren(element?: CalculatorViewItem): Thenable<CalculatorViewItem[]> {
if (!element) {
// 根节点
return Promise.resolve([
new CalculatorViewItem('Languages', vscode.TreeItemCollapsibleState.Expanded, {
command: 'universalCalculator.manageAdapters',
title: 'Manage Languages'
}),
new CalculatorViewItem('History', vscode.TreeItemCollapsibleState.Collapsed, {
command: 'universalCalculator.showHistory',
title: 'Show History'
}),
new CalculatorViewItem('Variables', vscode.TreeItemCollapsibleState.Collapsed, {
command: 'universalCalculator.manageVariables',
title: 'Manage Variables'
}),
new CalculatorViewItem('Workflows', vscode.TreeItemCollapsibleState.Collapsed, {
command: 'universalCalculator.manageWorkflows',
title: 'Manage Workflows'
})
]);
}

if (element.label === 'Languages') {
return this.getLanguageItems();
}

if (element.label === 'History') {
return this.getHistoryItems();
}

return Promise.resolve([]);
}

private async getLanguageItems(): Promise<CalculatorViewItem[]> {
const languages = this.languageManager.getAvailableAdapters();
const items: CalculatorViewItem[] = [];

for (const language of languages) {
const info = this.languageManager.getAdapterInfo(language);
if (info) {
const item = new CalculatorViewItem(
info.name,
vscode.TreeItemCollapsibleState.None,
{
command: 'universalCalculator.switchLanguage',
title: `Switch to ${info.name}`,
arguments: [language]
}
);
item.description = info.version;
item.tooltip = `Capabilities: ${info.capabilities.join(', ')}`;
item.iconPath = this.getLanguageIcon(language);
items.push(item);
}
}

return items;
}

refresh(): void {
this._onDidChangeTreeData.fire(undefined);
}
}

八、扩展性设计实现

8.1 插件化架构实现

// src/core/PluginSystem.ts
export interface CalculatorPlugin {
readonly id: string;
readonly name: string;
readonly version: string;
readonly dependencies?: string[];

initialize(context: PluginContext): Promise<void>;
register(registry: PluginRegistry): Promise<void>;
terminate(): Promise<void>;
}

export class PluginSystem {
private plugins: Map<string, CalculatorPlugin> = new Map();
private pluginContexts: Map<string, PluginContext> = new Map();
private registry = new PluginRegistry();

async loadPlugin(pluginPath: string): Promise<void> {
try {
// 动态加载插件模块
const pluginModule = await import(pluginPath);
const plugin: CalculatorPlugin = pluginModule.default || pluginModule;

// 检查依赖
await this.checkDependencies(plugin);

// 创建插件上下文
const context = this.createPluginContext(plugin);
this.pluginContexts.set(plugin.id, context);

// 初始化插件
await plugin.initialize(context);

// 注册插件功能
await plugin.register(this.registry);

this.plugins.set(plugin.id, plugin);

vscode.window.showInformationMessage(`插件 ${plugin.name} 已加载`);

} catch (error) {
vscode.window.showErrorMessage(`加载插件失败: ${error.message}`);
}
}

async loadPluginsFromDirectory(directory: string): Promise<void> {
const fs = require('fs');
const path = require('path');

const pluginFiles = fs.readdirSync(directory)
.filter((file: string) => file.endsWith('.js') || file.endsWith('.ts'));

for (const file of pluginFiles) {
const pluginPath = path.join(directory, file);
await this.loadPlugin(pluginPath);
}
}

private async checkDependencies(plugin: CalculatorPlugin): Promise<void> {
if (!plugin.dependencies) return;

for (const dep of plugin.dependencies) {
if (!this.plugins.has(dep)) {
throw new Error(`缺少依赖插件: ${dep}`);
}
}
}

private createPluginContext(plugin: CalculatorPlugin): PluginContext {
return {
pluginId: plugin.id,
extensionContext: this.extensionContext,
languageManager: this.languageManager,
calculatorRegistry: this.calculatorRegistry,
protocolManager: this.protocolManager,
uiManager: this.uiManager,
config: vscode.workspace.getConfiguration(`universalCalculator.plugins.${plugin.id}`),
logger: this.createPluginLogger(plugin.id)
};
}
}

8.2 自定义协议实现

// src/protocols/CustomProtocol.ts
export class CustomProtocol implements CommunicationProtocol {
readonly name = 'custom';
readonly version = '1.0.0';
readonly supportsBinary = true;
readonly supportsStreaming = true;

private messageHandlers: Map<string, MessageHandler> = new Map();
private connection: any = null;

async initialize(config: ProtocolConfig): Promise<void> {
// 加载自定义协议实现
const protocolImpl = await this.loadProtocolImplementation(config.options?.implementation);

this.connection = await protocolImpl.connect(config.endpoint, config.options);

// 设置消息处理器
this.connection.on('message', this.handleMessage.bind(this));
this.connection.on('error', this.handleError.bind(this));
}

async send(request: ProtocolRequest): Promise<ProtocolResponse> {
return new Promise((resolve, reject) => {
const messageId = this.generateMessageId();