应用程序插件开发完整指南

一、插件开发准备工作

1.1 核心准备要素

1.2 详细准备清单

准备类别	具体事项	重要性
需求分析	明确插件要解决什么问题	★★★★★
	确定目标用户和使用场景	★★★★☆
	定义插件与宿主的交互方式	★★★★★
技术调研	分析宿主应用的扩展机制	★★★★★
	选择合适的开发语言和框架	★★★★☆
	评估性能和安全性要求	★★★★☆
环境搭建	安装开发工具和SDK	★★★★★
	配置调试环境	★★★★☆
	设置测试框架	★★★★☆
设计规划	设计插件接口和数据结构	★★★★★
	制定错误处理机制	★★★★☆
	规划插件生命周期	★★★★☆

二、Python插件开发实例

2.1 场景：为Python数据分析平台开发数据处理插件

2.1.1 准备工具

# 必需工具
python >= 3.8
pip >= 20.0

# 开发工具包
pip install setuptools wheel  # 打包工具
pip install black flake8 mypy  # 代码规范
pip install pytest pytest-cov  # 测试框架
pip install sphinx sphinx-rtd-theme  # 文档生成

# 开发环境配置
mkdir data-processor-plugin
cd data-processor-plugin
python -m venv .venv
source .venv/bin/activate  # Linux/Mac
# 或 .venv\Scripts\activate  # Windows

2.1.2 项目结构设计

data-processor-plugin/
├── README.md
├── setup.py
├── pyproject.toml
├── requirements.txt
├── src/
│   └── data_processor/
│       ├── __init__.py
│       ├── plugin.py
│       ├── processors/
│       │   ├── __init__.py
│       │   ├── json_processor.py
│       │   ├── csv_processor.py
│       │   └── xml_processor.py
│       └── utils/
│           ├── __init__.py
│           └── helpers.py
├── tests/
│   ├── __init__.py
│   ├── test_plugin.py
│   └── test_processors.py
├── examples/
│   └── basic_usage.py
└── docs/
    └── index.md

2.1.3 插件接口定义

# src/data_processor/__init__.py
"""
数据处理插件系统
"""
from abc import ABC, abstractmethod
from typing import Any, Dict, List, Optional
import json
import logging
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum

# 插件状态枚举
class PluginStatus(Enum):
    DISABLED = "disabled"
    LOADED = "loaded"
    RUNNING = "running"
    ERROR = "error"
    STOPPED = "stopped"

# 插件事件
@dataclass
class PluginEvent:
    plugin_id: str
    event_type: str
    data: Dict[str, Any]
    timestamp: datetime = field(default_factory=datetime.now)

# 插件上下文
@dataclass
class PluginContext:
    """插件运行时上下文"""
    plugin_id: str
    config: Dict[str, Any]
    logger: logging.Logger
    data_dir: str
    temp_dir: str
    cache_dir: str
    
    def get_config(self, key: str, default: Any = None) -> Any:
        """获取配置项"""
        return self.config.get(f"plugins.{self.plugin_id}.{key}", default)
    
    def emit_event(self, event_type: str, data: Dict[str, Any]) -> None:
        """发射事件"""
        event = PluginEvent(
            plugin_id=self.plugin_id,
            event_type=event_type,
            data=data
        )
        # 实际应用中会发送到事件总线
        self.logger.info(f"Event emitted: {event_type}")

# 插件基础接口
class BasePlugin(ABC):
    """插件基础抽象类"""
    
    @property
    @abstractmethod
    def plugin_id(self) -> str:
        """插件唯一标识"""
        pass
    
    @property
    @abstractmethod
    def name(self) -> str:
        """插件名称"""
        pass
    
    @property
    @abstractmethod
    def version(self) -> str:
        """插件版本"""
        pass
    
    @property
    @abstractmethod
    def description(self) -> str:
        """插件描述"""
        pass
    
    @property
    @abstractmethod
    def author(self) -> str:
        """插件作者"""
        pass
    
    @property
    def dependencies(self) -> List[str]:
        """依赖插件列表"""
        return []
    
    @abstractmethod
    def initialize(self, context: PluginContext) -> None:
        """初始化插件"""
        pass
    
    @abstractmethod
    def start(self) -> None:
        """启动插件"""
        pass
    
    @abstractmethod
    def stop(self) -> None:
        """停止插件"""
        pass
    
    @abstractmethod
    def process(self, data: Any, **kwargs) -> Any:
        """处理数据"""
        pass
    
    def get_status(self) -> PluginStatus:
        """获取插件状态"""
        return getattr(self, '_status', PluginStatus.DISABLED)
    
    def validate(self) -> bool:
        """验证插件配置"""
        return True

2.1.4 具体插件实现

# src/data_processor/plugin.py
import logging
import pandas as pd
import numpy as np
from typing import Any, Dict, List, Optional
import asyncio
from concurrent.futures import ThreadPoolExecutor
from . import BasePlugin, PluginContext, PluginStatus

class DataProcessorPlugin(BasePlugin):
    """
    数据处理插件示例
    支持多种数据格式的处理和转换
    """
    
    def __init__(self):
        self._status = PluginStatus.DISABLED
        self.context = None
        self.executor = None
        self.processors = {}
        self.cache = {}
        
    @property
    def plugin_id(self) -> str:
        return "com.example.data-processor"
    
    @property
    def name(self) -> str:
        return "Data Processor"
    
    @property
    def version(self) -> str:
        return "1.0.0"
    
    @property
    def description(self) -> str:
        return "支持JSON、CSV、Excel等格式的数据处理插件"
    
    @property
    def author(self) -> str:
        return "Data Team"
    
    @property
    def dependencies(self) -> List[str]:
        return ["com.example.logger>=1.0.0"]
    
    def initialize(self, context: PluginContext) -> None:
        """初始化插件"""
        self.context = context
        self._status = PluginStatus.LOADED
        
        # 初始化线程池
        max_workers = context.get_config("max_workers", 4)
        self.executor = ThreadPoolExecutor(max_workers=max_workers)
        
        # 注册处理器
        self._register_processors()
        
        # 加载配置
        self._load_configuration()
        
        self.context.logger.info(f"插件初始化完成: {self.name} v{self.version}")
    
    def start(self) -> None:
        """启动插件"""
        if self._status != PluginStatus.LOADED:
            raise RuntimeError("插件未初始化")
        
        self._status = PluginStatus.RUNNING
        
        # 启动后台任务
        asyncio.create_task(self._background_task())
        
        # 预热缓存
        self._warmup_cache()
        
        self.context.logger.info("插件已启动")
    
    def stop(self) -> None:
        """停止插件"""
        self._status = PluginStatus.STOPPED
        
        # 关闭线程池
        if self.executor:
            self.executor.shutdown(wait=True)
        
        # 清理缓存
        self.cache.clear()
        
        self.context.logger.info("插件已停止")
    
    def process(self, data: Any, processor_type: str = "auto", **kwargs) -> Any:
        """
        处理数据
        Args:
            data: 输入数据
            processor_type: 处理器类型，auto为自动检测
            **kwargs: 额外参数
        Returns:
            处理后的数据
        """
        if self._status != PluginStatus.RUNNING:
            raise RuntimeError("插件未运行")
        
        try:
            # 自动检测数据类型
            if processor_type == "auto":
                processor_type = self._detect_data_type(data)
            
            # 获取处理器
            processor = self.processors.get(processor_type)
            if not processor:
                raise ValueError(f"不支持的数据类型: {processor_type}")
            
            # 异步处理数据
            if kwargs.get("async", False):
                future = self.executor.submit(processor, data, **kwargs)
                return future
            
            # 同步处理数据
            result = processor(data, **kwargs)
            
            # 记录处理日志
            self.context.emit_event("data.processed", {
                "type": processor_type,
                "size": len(str(data)),
                "success": True
            })
            
            return result
            
        except Exception as e:
            self.context.logger.error(f"数据处理失败: {e}")
            
            self.context.emit_event("data.process_error", {
                "type": processor_type,
                "error": str(e)
            })
            
            raise
    
    def _register_processors(self) -> None:
        """注册数据处理器"""
        self.processors = {
            "json": self._process_json,
            "csv": self._process_csv,
            "excel": self._process_excel,
            "dataframe": self._process_dataframe,
            "dict": self._process_dict
        }
    
    def _process_json(self, data, **kwargs):
        """处理JSON数据"""
        if isinstance(data, str):
            return pd.read_json(data, **kwargs)
        elif isinstance(data, dict) or isinstance(data, list):
            return pd.DataFrame(data)
        else:
            raise ValueError("无效的JSON数据")
    
    def _process_csv(self, data, **kwargs):
        """处理CSV数据"""
        if isinstance(data, str):
            # CSV字符串
            import io
            return pd.read_csv(io.StringIO(data), **kwargs)
        elif hasattr(data, 'read'):
            # 文件对象
            return pd.read_csv(data, **kwargs)
        else:
            raise ValueError("无效的CSV数据")
    
    def _process_excel(self, data, **kwargs):
        """处理Excel数据"""
        if isinstance(data, str):
            # 文件路径
            return pd.read_excel(data, **kwargs)
        elif hasattr(data, 'read'):
            # 文件对象
            return pd.read_excel(data, **kwargs)
        else:
            raise ValueError("无效的Excel数据")
    
    def _process_dataframe(self, data, **kwargs):
        """处理DataFrame数据"""
        if not isinstance(data, pd.DataFrame):
            raise ValueError("需要DataFrame类型数据")
        
        # 应用转换
        transformations = kwargs.get("transformations", [])
        result = data.copy()
        
        for transform in transformations:
            if transform["type"] == "filter":
                result = result.query(transform["condition"])
            elif transform["type"] == "map":
                result[transform["column"]] = result[transform["column"]].map(
                    transform["function"]
                )
            elif transform["type"] == "aggregate":
                result = result.groupby(transform["by"]).agg(transform["agg"])
        
        return result
    
    def _process_dict(self, data, **kwargs):
        """处理字典数据"""
        if not isinstance(data, dict):
            raise ValueError("需要字典类型数据")
        
        # 转换为DataFrame
        df = pd.DataFrame([data])
        
        # 应用处理
        if "rename" in kwargs:
            df = df.rename(columns=kwargs["rename"])
        
        if "drop" in kwargs:
            df = df.drop(columns=kwargs["drop"])
        
        return df
    
    def _detect_data_type(self, data: Any) -> str:
        """自动检测数据类型"""
        if isinstance(data, pd.DataFrame):
            return "dataframe"
        elif isinstance(data, dict):
            return "dict"
        elif isinstance(data, str):
            if data.strip().startswith(('{', '[')):
                return "json"
            elif ',' in data or '\t' in data:
                return "csv"
        elif hasattr(data, 'read'):
            # 文件对象
            if hasattr(data, 'name') and data.name.endswith('.xlsx'):
                return "excel"
        
        raise ValueError("无法识别的数据类型")
    
    def _load_configuration(self) -> None:
        """加载配置"""
        config = self.context.config.get("plugins", {}).get(self.plugin_id, {})
        
        # 缓存配置
        cache_size = config.get("cache_size", 100)
        self.cache = LRUCache(capacity=cache_size)
        
        # 性能配置
        self.batch_size = config.get("batch_size", 1000)
    
    async def _background_task(self):
        """后台任务"""
        while self._status == PluginStatus.RUNNING:
            try:
                # 定期清理过期缓存
                self._cleanup_cache()
                
                # 收集统计信息
                await self._collect_metrics()
                
                await asyncio.sleep(60)  # 每分钟执行一次
                
            except asyncio.CancelledError:
                break
            except Exception as e:
                self.context.logger.error(f"后台任务错误: {e}")
                await asyncio.sleep(10)
    
    def _warmup_cache(self):
        """预热缓存"""
        # 预加载常用数据
        pass
    
    def _cleanup_cache(self):
        """清理缓存"""
        # 移除过期项
        pass
    
    async def _collect_metrics(self):
        """收集性能指标"""
        metrics = {
            "timestamp": datetime.now().isoformat(),
            "cache_size": len(self.cache),
            "status": self._status.value,
            "active_threads": self.executor._max_workers
        }
        
        self.context.emit_event("plugin.metrics", {"metrics": metrics})
    
    def validate(self) -> bool:
        """验证插件"""
        required_packages = ["pandas", "numpy", "openpyxl"]
        
        for package in required_packages:
            try:
                __import__(package)
            except ImportError:
                self.context.logger.error(f"缺少依赖包: {package}")
                return False
        
        return True

# LRU缓存实现
class LRUCache:
    """LRU缓存"""
    def __init__(self, capacity: int = 100):
        self.capacity = capacity
        self.cache = {}
        self.order = []
    
    def get(self, key):
        """获取缓存项"""
        if key not in self.cache:
            return None
        
        # 移动到最近使用
        self.order.remove(key)
        self.order.append(key)
        return self.cache[key]
    
    def put(self, key, value):
        """添加缓存项"""
        if key in self.cache:
            self.order.remove(key)
        elif len(self.cache) >= self.capacity:
            # 移除最久未使用
            oldest = self.order.pop(0)
            del self.cache[oldest]
        
        self.cache[key] = value
        self.order.append(key)
    
    def __len__(self):
        return len(self.cache)
    
    def clear(self):
        """清空缓存"""
        self.cache.clear()
        self.order.clear()

2.1.5 插件配置文件

# plugin.yaml
plugin:
  id: "com.example.data-processor"
  name: "Data Processor"
  version: "1.0.0"
  description: "数据处理插件，支持多种格式转换"
  author: "Data Team"
  license: "MIT"
  
  entry_point: "data_processor.plugin:DataProcessorPlugin"
  
  dependencies:
    - "pandas>=1.3.0"
    - "numpy>=1.21.0"
    - "openpyxl>=3.0.0"
  
  configuration:
    max_workers: 4
    cache_size: 100
    batch_size: 1000
    log_level: "INFO"
  
  permissions:
    - "filesystem:read"
    - "filesystem:write"
    - "network:limited"
  
  hooks:
    post_install: "scripts/setup.py"
    pre_uninstall: "scripts/cleanup.py"

2.1.6 插件管理器

# src/data_processor/manager.py
import importlib
import importlib.util
import sys
import os
from pathlib import Path
from typing import Dict, List, Optional, Any
import yaml
import logging
from concurrent.futures import ThreadPoolExecutor
import threading
import hashlib

class PluginManager:
    """
    插件管理器
    负责插件的加载、卸载和生命周期管理
    """
    
    def __init__(self, config: Dict[str, Any]):
        self.config = config
        self.plugins: Dict[str, BasePlugin] = {}
        self.plugin_info: Dict[str, Dict] = {}
        self.logger = logging.getLogger("PluginManager")
        
        # 插件目录
        self.plugin_dirs = config.get('plugin_dirs', ['./plugins'])
        if isinstance(self.plugin_dirs, str):
            self.plugin_dirs = [self.plugin_dirs]
        
        # 创建插件目录
        for plugin_dir in self.plugin_dirs:
            Path(plugin_dir).mkdir(parents=True, exist_ok=True)
        
        # 线程池
        self.executor = ThreadPoolExecutor(
            max_workers=config.get('max_workers', 10),
            thread_name_prefix='plugin_worker'
        )
        
        self._lock = threading.RLock()
        
    def discover_plugins(self) -> List[str]:
        """发现可用插件"""
        discovered = []
        
        for plugin_dir in self.plugin_dirs:
            dir_path = Path(plugin_dir)
            if not dir_path.exists():
                continue
            
            for item in dir_path.iterdir():
                if self._is_plugin(item):
                    discovered.append(str(item))
        
        return discovered
    
    def load_plugin(self, plugin_path: str) -> Optional[BasePlugin]:
        """加载插件"""
        with self._lock:
            try:
                # 1. 加载插件模块
                plugin_module = self._load_module(plugin_path)
                
                # 2. 获取插件信息
                plugin_info = self._get_plugin_info(plugin_path)
                plugin_id = plugin_info['id']
                
                if plugin_id in self.plugins:
                    self.logger.warning(f"插件已加载: {plugin_id}")
                    return self.plugins[plugin_id]
                
                # 3. 创建插件实例
                plugin_class = self._find_plugin_class(plugin_module)
                plugin_instance = plugin_class()
                
                # 4. 创建上下文
                context = self._create_context(plugin_id, plugin_info)
                
                # 5. 初始化插件
                plugin_instance.initialize(context)
                
                # 6. 注册插件
                self.plugins[plugin_id] = plugin_instance
                self.plugin_info[plugin_id] = plugin_info
                
                self.logger.info(f"插件加载成功: {plugin_id}")
                return plugin_instance
                
            except Exception as e:
                self.logger.error(f"加载插件失败 {plugin_path}: {e}")
                return None
    
    def unload_plugin(self, plugin_id: str) -> bool:
        """卸载插件"""
        with self._lock:
            if plugin_id not in self.plugins:
                return False
            
            try:
                plugin = self.plugins[plugin_id]
                
                # 停止插件
                if plugin.get_status() != PluginStatus.STOPPED:
                    plugin.stop()
                
                # 移除插件
                del self.plugins[plugin_id]
                del self.plugin_info[plugin_id]
                
                self.logger.info(f"插件已卸载: {plugin_id}")
                return True
                
            except Exception as e:
                self.logger.error(f"卸载插件失败 {plugin_id}: {e}")
                return False
    
    def _is_plugin(self, path: Path) -> bool:
        """判断是否为插件"""
        if path.is_dir():
            # 目录型插件
            return (path / "plugin.yaml").exists() or (path / "__init__.py").exists()
        elif path.is_file():
            # 文件型插件
            return path.suffix in ['.py', '.zip']
        return False
    
    def _load_module(self, plugin_path: str):
        """加载Python模块"""
        path = Path(plugin_path)
        
        if path.is_dir():
            # 目录型插件
            init_file = path / "__init__.py"
            if init_file.exists():
                # 将目录添加到Python路径
                sys.path.insert(0, str(path.parent))
                module_name = path.name
                return importlib.import_module(module_name)
        
        # 文件型插件
        spec = importlib.util.spec_from_file_location(
            f"plugin_{hashlib.md5(str(path).encode()).hexdigest()[:8]}",
            str(path)
        )
        module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(module)
        return module
    
    def _get_plugin_info(self, plugin_path: str) -> Dict[str, Any]:
        """获取插件信息"""
        path = Path(plugin_path)
        
        # 从YAML文件读取
        yaml_file = path / "plugin.yaml" if path.is_dir() else path.with_suffix('.yaml')
        if yaml_file.exists():
            with open(yaml_file, 'r', encoding='utf-8') as f:
                info = yaml.safe_load(f)
                return info.get('plugin', {})
        
        # 从插件类读取
        return {}
    
    def _find_plugin_class(self, module):
        """查找插件类"""
        import inspect
        for name, obj in inspect.getmembers(module):
            if (inspect.isclass(obj) and 
                issubclass(obj, BasePlugin) and 
                obj != BasePlugin):
                return obj
        raise ValueError("未找到插件类")
    
    def _create_context(self, plugin_id: str, plugin_info: Dict) -> PluginContext:
        """创建插件上下文"""
        import tempfile
        
        # 创建插件工作目录
        work_dir = Path(self.config.get('work_dir', './plugin_data')) / plugin_id
        work_dir.mkdir(parents=True, exist_ok=True)
        
        # 创建临时目录
        temp_dir = Path(tempfile.mkdtemp(prefix=f"plugin_{plugin_id}_"))
        
        # 创建日志器
        logger = logging.getLogger(f"Plugin.{plugin_id}")
        
        return PluginContext(
            plugin_id=plugin_id,
            config=self.config,
            logger=logger,
            data_dir=str(work_dir),
            temp_dir=str(temp_dir),
            cache_dir=str(work_dir / "cache")
        )
    
    def get_plugin(self, plugin_id: str) -> Optional[BasePlugin]:
        """获取插件实例"""
        return self.plugins.get(plugin_id)
    
    def list_plugins(self) -> List[Dict[str, Any]]:
        """列出所有插件"""
        return [
            {
                "id": pid,
                "name": info.get("name", ""),
                "version": info.get("version", ""),
                "status": plugin.get_status().value
            }
            for pid, (plugin, info) in enumerate(zip(self.plugins.values(), self.plugin_info.values()))
        ]

2.1.7 使用示例

# examples/basic_usage.py
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.dirname(__file__)))

from src.data_processor.manager import PluginManager
import logging

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

def main():
    # 创建插件管理器配置
    config = {
        'plugin_dirs': ['./plugins'],
        'work_dir': './plugin_data',
        'max_workers': 4
    }
    
    # 创建插件管理器
    manager = PluginManager(config)
    
    try:
        # 发现插件
        print("发现插件...")
        plugin_paths = manager.discover_plugins()
        print(f"发现 {len(plugin_paths)} 个插件")
        
        # 加载插件
        for plugin_path in plugin_paths:
            print(f"加载插件: {plugin_path}")
            plugin = manager.load_plugin(plugin_path)
            
            if plugin:
                # 启动插件
                plugin.start()
                print(f"插件已启动: {plugin.name}")
                
                # 使用插件处理数据
                test_data = {
                    "name": "John",
                    "age": 30,
                    "city": "New York"
                }
                
                result = plugin.process(test_data, processor_type="dict")
                print(f"处理结果: {result}")
                
                # 停止插件
                plugin.stop()
                print(f"插件已停止: {plugin.name}")
    
    except Exception as e:
        print(f"错误: {e}")
    
    finally:
        # 清理
        print("清理插件管理器...")

if __name__ == "__main__":
    main()

2.1.8 打包和发布

# setup.py
from setuptools import setup, find_packages

with open("README.md", "r", encoding="utf-8") as fh:
    long_description = fh.read()

with open("requirements.txt", "r", encoding="utf-8") as fh:
    requirements = fh.read().splitlines()

setup(
    name="data-processor-plugin",
    version="1.0.0",
    author="Data Team",
    author_email="team@example.com",
    description="数据处理插件系统",
    long_description=long_description,
    long_description_content_type="text/markdown",
    url="https://github.com/example/data-processor-plugin",
    
    package_dir={"": "src"},
    packages=find_packages(where="src"),
    
    classifiers=[
        "Development Status :: 4 - Beta",
        "Intended Audience :: Developers",
        "Topic :: Software Development :: Libraries :: Python Modules",
        "License :: OSI Approved :: MIT License",
        "Programming Language :: Python :: 3",
        "Programming Language :: Python :: 3.8",
        "Programming Language :: Python :: 3.9",
        "Programming Language :: Python :: 3.10",
    ],
    
    python_requires=">=3.8",
    install_requires=requirements,
    
    extras_require={
        "dev": [
            "pytest>=7.0.0",
            "pytest-cov>=4.0.0",
            "black>=22.0.0",
            "flake8>=5.0.0",
        ],
    },
    
    entry_points={
        "console_scripts": [
            "data-processor=data_processor.cli:main",
        ],
    },
    
    include_package_data=True,
    package_data={
        "data_processor": [
            "schemas/*.json",
            "templates/*.j2",
        ],
    },
)

三、TypeScript插件开发实例

3.1 场景：为VS Code开发代码格式化插件

3.1.1 准备工具

# 必需工具
node.js >= 16.0.0
npm >= 8.0.0  # 或 yarn >= 1.22.0

# 安装VS Code扩展开发工具
npm install -g yo generator-code vsce

# 创建项目
yo code

# 选择插件类型
# ? What type of extension do you want to create?
#   New Extension (TypeScript)
# ? What's the name of your extension?
#   code-formatter-extension
# ? What's the identifier of your extension?
#   code-formatter
# ? What's the description of your extension?
#   Advanced code formatter for multiple languages
# ? Initialize a git repository?
#   Yes
# ? Which package manager to use?
#   npm

3.1.2 项目结构

code-formatter-extension/
├── .vscode/
│   ├── launch.json      # 调试配置
│   ├── settings.json    # 工作区设置
│   └── tasks.json       # 任务配置
├── src/
│   ├── extension.ts     # 插件主入口
│   ├── formatter/
│   │   ├── Formatter.ts
│   │   ├── JSONFormatter.ts
│   │   ├── TypeScriptFormatter.ts
│   │   └── index.ts
│   ├── providers/
│   │   ├── FormattingProvider.ts
│   │   └── CompletionProvider.ts
│   └── utils/
│       ├── Logger.ts
│       └── Config.ts
├── test/
│   ├── suite/
│   │   ├── extension.test.ts
│   │   └── index.ts
│   └── runTest.ts
├── package.json         # 插件清单
├── tsconfig.json        # TypeScript配置
├── webpack.config.js    # Webpack配置（可选）
├── .eslintrc.json      # ESLint配置
└── README.md

3.1.3 插件主入口

// src/extension.ts
import * as vscode from 'vscode';
import { FormatterManager } from './formatter/FormatterManager';
import { FormattingProvider } from './providers/FormattingProvider';
import { Logger } from './utils/Logger';
import { Configuration } from './utils/Config';

// 插件激活函数
export function activate(context: vscode.ExtensionContext) {
    const logger = new Logger('CodeFormatter');
    logger.info('插件正在激活...');
    
    try {
        // 读取配置
        const config = new Configuration();
        
        // 初始化格式化管理器
        const formatterManager = new FormatterManager(context, config);
        
        // 注册格式化提供者
        const formattingProvider = new FormattingProvider(formatterManager, config);
        
        // 注册文档格式化提供者
        const documentSelector: vscode.DocumentSelector = [
            { language: 'javascript' },
            { language: 'typescript' },
            { language: 'json' },
            { language: 'html' },
            { language: 'css' },
            { language: 'python' }
        ];
        
        const formatProvider = vscode.languages.registerDocumentFormattingEditProvider(
            documentSelector,
            formattingProvider
        );
        
        // 注册范围格式化提供者
        const rangeFormatProvider = vscode.languages.registerDocumentRangeFormattingEditProvider(
            documentSelector,
            formattingProvider
        );
        
        // 注册命令
        const formatCommand = vscode.commands.registerCommand(
            'codeFormatter.formatDocument',
            () => formattingProvider.formatDocument()
        );
        
        const formatSelectionCommand = vscode.commands.registerCommand(
            'codeFormatter.formatSelection',
            () => formattingProvider.formatSelection()
        );
        
        // 添加到订阅列表
        context.subscriptions.push(
            formatProvider,
            rangeFormatProvider,
            formatCommand,
            formatSelectionCommand,
            formatterManager
        );
        
        // 注册配置变更监听
        vscode.workspace.onDidChangeConfiguration((event) => {
            if (event.affectsConfiguration('codeFormatter')) {
                config.refresh();
                logger.info('配置已更新');
            }
        });
        
        // 启动后台任务
        startBackgroundTasks(context, logger);
        
        logger.info('插件激活成功');
        
        return {
            formatterManager,
            formattingProvider
        };
        
    } catch (error) {
        logger.error(`插件激活失败: ${error}`);
        throw error;
    }
}

// 插件停用函数
export function deactivate() {
    console.log('插件正在停用...');
    // 清理资源
}

// 后台任务
function startBackgroundTasks(context: vscode.ExtensionContext, logger: Logger) {
    // 定期检查更新
    const updateCheckInterval = setInterval(() => {
        checkForUpdates(logger);
    }, 24 * 60 * 60 * 1000); // 每天检查一次
    
    // 清理任务
    context.subscriptions.push({
        dispose: () => clearInterval(updateCheckInterval)
    });
}

async function checkForUpdates(logger: Logger) {
    try {
        // 检查更新逻辑
        logger.debug('正在检查更新...');
    } catch (error) {
        logger.error(`更新检查失败: ${error}`);
    }
}

3.1.4 格式化管理器

// src/formatter/FormatterManager.ts
import * as vscode from 'vscode';
import { BaseFormatter } from './BaseFormatter';
import { JSONFormatter } from './JSONFormatter';
import { TypeScriptFormatter } from './TypeScriptFormatter';
import { HTMLFormatter } from './HTMLFormatter';
import { CSSFormatter } from './CSSFormatter';
import { PythonFormatter } from './PythonFormatter';
import { Logger } from '../utils/Logger';
import { Configuration } from '../utils/Config';

export class FormatterManager implements vscode.Disposable {
    private formatters: Map<string, BaseFormatter> = new Map();
    private logger: Logger;
    private config: Configuration;
    
    constructor(context: vscode.ExtensionContext, config: Configuration) {
        this.logger = new Logger('FormatterManager');
        this.config = config;
        
        this.initializeFormatters(context);
    }
    
    private initializeFormatters(context: vscode.ExtensionContext): void {
        // 注册所有格式化器
        this.registerFormatter('json', new JSONFormatter(context, this.config));
        this.registerFormatter('typescript', new TypeScriptFormatter(context, this.config));
        this.registerFormatter('javascript', new TypeScriptFormatter(context, this.config)); // 复用TS格式化器
        this.registerFormatter('html', new HTMLFormatter(context, this.config));
        this.registerFormatter('css', new CSSFormatter(context, this.config));
        this.registerFormatter('python', new PythonFormatter(context, this.config));
        
        this.logger.info(`已注册 ${this.formatters.size} 个格式化器`);
    }
    
    registerFormatter(languageId: string, formatter: BaseFormatter): void {
        this.formatters.set(languageId, formatter);
        this.logger.debug(`注册格式化器: ${languageId}`);
    }
    
    getFormatter(languageId: string): BaseFormatter | undefined {
        return this.formatters.get(languageId);
    }
    
    async formatDocument(
        document: vscode.TextDocument,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]> {
        const languageId = document.languageId;
        const formatter = this.getFormatter(languageId);
        
        if (!formatter) {
            this.logger.warn(`未找到对应语言(${languageId})的格式化器`);
            return [];
        }
        
        try {
            this.logger.debug(`开始格式化文档: ${document.fileName}`);
            
            const startTime = Date.now();
            const edits = await formatter.formatDocument(document, options);
            const duration = Date.now() - startTime;
            
            this.logger.info(`文档格式化完成，耗时: ${duration}ms`);
            
            return edits;
            
        } catch (error) {
            this.logger.error(`格式化失败: ${error}`);
            throw error;
        }
    }
    
    async formatRange(
        document: vscode.TextDocument,
        range: vscode.Range,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]> {
        const languageId = document.languageId;
        const formatter = this.getFormatter(languageId);
        
        if (!formatter) {
            return [];
        }
        
        try {
            this.logger.debug(`开始格式化范围: ${document.fileName}`);
            
            const edits = await formatter.formatRange(document, range, options);
            
            return edits;
            
        } catch (error) {
            this.logger.error(`范围格式化失败: ${error}`);
            throw error;
        }
    }
    
    async formatOnType(
        document: vscode.TextDocument,
        position: vscode.Position,
        ch: string,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]> {
        const languageId = document.languageId;
        const formatter = this.getFormatter(languageId);
        
        if (!formatter || !formatter.supportsOnTypeFormatting) {
            return [];
        }
        
        try {
            return await formatter.formatOnType(document, position, ch, options);
        } catch (error) {
            this.logger.error(`输入时格式化失败: ${error}`);
            return [];
        }
    }
    
    // 获取支持的格式器列表
    getSupportedLanguages(): string[] {
        return Array.from(this.formatters.keys());
    }
    
    // 获取格式器信息
    getFormatterInfo(): Array<{ language: string; name: string; version: string }> {
        const info: Array<{ language: string; name: string; version: string }> = [];
        
        for (const [language, formatter] of this.formatters) {
            info.push({
                language,
                name: formatter.name,
                version: formatter.version
            });
        }
        
        return info;
    }
    
    dispose(): void {
        // 清理所有格式器
        for (const formatter of this.formatters.values()) {
            formatter.dispose();
        }
        this.formatters.clear();
        this.logger.info('格式化管理器已清理');
    }
}

3.1.5 基础格式化器

// src/formatter/BaseFormatter.ts
import * as vscode from 'vscode';
import { Configuration } from '../utils/Config';

export abstract class BaseFormatter implements vscode.Disposable {
    abstract readonly name: string;
    abstract readonly version: string;
    abstract readonly supportsOnTypeFormatting: boolean;
    
    constructor(
        protected context: vscode.ExtensionContext,
        protected config: Configuration
    ) {}
    
    abstract formatDocument(
        document: vscode.TextDocument,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]>;
    
    abstract formatRange(
        document: vscode.TextDocument,
        range: vscode.Range,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]>;
    
    formatOnType?(
        document: vscode.TextDocument,
        position: vscode.Position,
        ch: string,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]>;
    
    // 默认实现：根据选项调整缩进
    protected adjustIndentation(
        text: string,
        options: vscode.FormattingOptions
    ): string {
        const { insertSpaces, tabSize } = options;
        
        if (!insertSpaces) {
            return text;
        }
        
        // 将制表符转换为空格
        const spaces = ' '.repeat(tabSize);
        return text.replace(/\t/g, spaces);
    }
    
    // 创建文本编辑
    protected createTextEdit(
        range: vscode.Range,
        newText: string
    ): vscode.TextEdit {
        return new vscode.TextEdit(range, newText);
    }
    
    // 计算范围文本
    protected getRangeText(
        document: vscode.TextDocument,
        range: vscode.Range
    ): string {
        return document.getText(range);
    }
    
    // 获取文档配置
    protected getDocumentConfig(
        document: vscode.TextDocument,
        key: string
    ): any {
        const config = vscode.workspace.getConfiguration('codeFormatter', document.uri);
        return config.get(key);
    }
    
    dispose(): void {
        // 子类可重写此方法以清理资源
    }
}

3.1.6 JSON格式化器实现

// src/formatter/JSONFormatter.ts
import * as vscode from 'vscode';
import { BaseFormatter } from './BaseFormatter';

export class JSONFormatter extends BaseFormatter {
    readonly name = 'JSON Formatter';
    readonly version = '1.0.0';
    readonly supportsOnTypeFormatting = false;
    
    async formatDocument(
        document: vscode.TextDocument,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]> {
        const text = document.getText();
        
        try {
            // 解析JSON
            const parsed = JSON.parse(text);
            
            // 格式化选项
            const indent = options?.insertSpaces 
                ? ' '.repeat(options.tabSize || 4)
                : '\t';
            
            // 重新序列化
            const formatted = JSON.stringify(parsed, null, indent);
            
            // 创建完整的文档范围
            const fullRange = new vscode.Range(
                document.positionAt(0),
                document.positionAt(text.length)
            );
            
            return [this.createTextEdit(fullRange, formatted)];
            
        } catch (error) {
            throw new Error(`JSON解析失败: ${error.message}`);
        }
    }
    
    async formatRange(
        document: vscode.TextDocument,
        range: vscode.Range,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]> {
        // 对于JSON，通常需要格式化整个文档
        return this.formatDocument(document, options);
    }
    
    // JSON不支持增量格式化
    formatOnType?(
        document: vscode.TextDocument,
        position: vscode.Position,
        ch: string,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]> {
        return Promise.resolve([]);
    }
}

3.1.7 TypeScript格式化器实现

// src/formatter/TypeScriptFormatter.ts
import * as vscode from 'vscode';
import * as ts from 'typescript';
import { BaseFormatter } from './BaseFormatter';

export class TypeScriptFormatter extends BaseFormatter {
    readonly name = 'TypeScript Formatter';
    readonly version = '1.0.0';
    readonly supportsOnTypeFormatting = true;
    
    private compilerOptions: ts.CompilerOptions;
    
    constructor(context: vscode.ExtensionContext, config: Configuration) {
        super(context, config);
        
        // 初始化TypeScript编译器选项
        this.compilerOptions = {
            target: ts.ScriptTarget.ES2020,
            module: ts.ModuleKind.CommonJS,
            strict: true,
            esModuleInterop: true,
            skipLibCheck: true,
            forceConsistentCasingInFileNames: true
        };
    }
    
    async formatDocument(
        document: vscode.TextDocument,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]> {
        const text = document.getText();
        const fileName = document.fileName;
        
        // 创建TypeScript源文件
        const sourceFile = ts.createSourceFile(
            fileName,
            text,
            ts.ScriptTarget.ES2020,
            true
        );
        
        // 获取格式化选项
        const formatOptions = this.getFormatOptions(options);
        
        // 使用TypeScript格式化API
        const formatResult = ts.formatting.formatNode(
            sourceFile,
            sourceFile,
            this.compilerOptions,
            formatOptions
        );
        
        // 获取格式化后的文本
        const printer = ts.createPrinter({
            newLine: ts.NewLineKind.LineFeed,
            removeComments: false
        });
        
        const formattedText = printer.printNode(
            ts.EmitHint.Unspecified,
            sourceFile,
            sourceFile
        );
        
        // 创建文本编辑
        const fullRange = new vscode.Range(
            document.positionAt(0),
            document.positionAt(text.length)
        );
        
        return [this.createTextEdit(fullRange, formattedText)];
    }
    
    async formatRange(
        document: vscode.TextDocument,
        range: vscode.Range,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]> {
        const text = this.getRangeText(document, range);
        const fileName = document.fileName;
        
        // 创建源文件
        const sourceFile = ts.createSourceFile(
            fileName,
            text,
            ts.ScriptTarget.ES2020,
            true
        );
        
        // 获取格式化选项
        const formatOptions = this.getFormatOptions(options);
        
        // 格式化节点
        const formatResult = ts.formatting.formatNode(
            sourceFile,
            sourceFile,
            this.compilerOptions,
            formatOptions
        );
        
        // 获取格式化后的文本
        const printer = ts.createPrinter({
            newLine: ts.NewLineKind.LineFeed
        });
        
        const formattedText = printer.printNode(
            ts.EmitHint.Unspecified,
            sourceFile,
            sourceFile
        );
        
        return [this.createTextEdit(range, formattedText)];
    }
    
    async formatOnType(
        document: vscode.TextDocument,
        position: vscode.Position,
        ch: string,
        options?: vscode.FormattingOptions
    ): Promise<vscode.TextEdit[]> {
        // 只在输入特定字符时触发
        const triggerChars = [';', '}', '\n'];
        
        if (!triggerChars.includes(ch)) {
            return [];
        }
        
        // 获取当前行
        const line = document.lineAt(position.line);
        const lineText = line.text;
        
        // 简单格式化：调整缩进
        const indent = this.calculateIndent(lineText, options);
        
        if (indent > 0) {
            const indentStr = options?.insertSpaces 
                ? ' '.repeat(indent * (options.tabSize || 4))
                : '\t'.repeat(indent);
            
            const editPosition = new vscode.Position(position.line, 0);
            const editRange = new vscode.Range(editPosition, editPosition);
            
            return [this.createTextEdit(editRange, indentStr)];
        }
        
        return [];
    }
    
    private getFormatOptions(options?: vscode.FormattingOptions): ts.FormatCodeSettings {
        const indentSize = options?.tabSize || 4;
        const convertTabsToSpaces = options?.insertSpaces || true;
        
        return {
            indentSize,
            tabSize: indentSize,
            convertTabsToSpaces,
            indentStyle: ts.IndentStyle.Smart,
            newLineCharacter: '\n',
            insertSpaceAfterCommaDelimiter: true,
            insertSpaceAfterSemicolonInForStatements: true,
            insertSpaceBeforeAndAfterBinaryOperators: true,
            insertSpaceAfterConstructor: false,
            insertSpaceAfterKeywordsInControlFlowStatements: true,
            insertSpaceAfterFunctionKeywordForAnonymousFunctions: true,
            insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,
            insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,
            insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: false,
            insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,
            insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false,
            insertSpaceAfterTypeAssertion: false,
            placeOpenBraceOnNewLineForFunctions: false,
            placeOpenBraceOnNewLineForControlBlocks: false
        };
    }
    
    private calculateIndent(lineText: string, options?: vscode.FormattingOptions): number {
        // 计算缩进级别
        const trimmed = lineText.trim();
        
        if (trimmed.endsWith('{')) {
            return 1; // 增加缩进
        } else if (trimmed.startsWith('}')) {
            return -1; // 减少缩进
        }
        
        return 0;
    }
    
    dispose(): void {
        // 清理TypeScript资源
    }
}

3.1.8 配置管理器

// src/utils/Config.ts
import * as vscode from 'vscode';

export interface FormatterConfig {
    enabled: boolean;
    formatOnSave: boolean;
    formatOnType: boolean;
    insertSpaces: boolean;
    tabSize: number;
    maxLineLength: number;
    trailingComma: 'none' | 'es5' | 'all';
    semi: boolean;
    singleQuote: boolean;
}

export class Configuration {
    private config: vscode.WorkspaceConfiguration;
    
    constructor() {
        this.refresh();
    }
    
    refresh(): void {
        this.config = vscode.workspace.getConfiguration('codeFormatter');
    }
    
    get<T>(key: string, defaultValue?: T): T {
        return this.config.get<T>(key, defaultValue as T);
    }
    
    update<T>(key: string, value: T): Thenable<void> {
        return this.config.update(key, value, vscode.ConfigurationTarget.Global);
    }
    
    // 获取完整配置
    getFormatterConfig(): FormatterConfig {
        return {
            enabled: this.get<boolean>('enabled', true),
            formatOnSave: this.get<boolean>('formatOnSave', false),
            formatOnType: this.get<boolean>('formatOnType', true),
            insertSpaces: this.get<boolean>('editor.insertSpaces', true),
            tabSize: this.get<number>('editor.tabSize', 4),
            maxLineLength: this.get<number>('maxLineLength', 80),
            trailingComma: this.get<'none' | 'es5' | 'all'>('trailingComma', 'es5'),
            semi: this.get<boolean>('semi', true),
            singleQuote: this.get<boolean>('singleQuote', false)
        };
    }
    
    // 获取语言特定配置
    getLanguageConfig(languageId: string): any {
        const languageConfig = this.config.get<any>('languageSettings', {});
        return languageConfig[languageId] || {};
    }
    
    // 检查是否启用
    isEnabled(languageId?: string): boolean {
        const globalEnabled = this.get<boolean>('enabled', true);
        
        if (!languageId) {
            return globalEnabled;
        }
        
        const languageConfig = this.getLanguageConfig(languageId);
        return languageConfig.enabled !== undefined 
            ? languageConfig.enabled 
            : globalEnabled;
    }
}

3.1.9 日志管理器

// src/utils/Logger.ts
import * as vscode from 'vscode';

export enum LogLevel {
    DEBUG = 0,
    INFO = 1,
    WARN = 2,
    ERROR = 3,
    NONE = 4
}

export class Logger {
    private channel: vscode.OutputChannel;
    private logLevel: LogLevel;
    
    constructor(name: string) {
        this.channel = vscode.window.createOutputChannel(name);
        this.logLevel = this.getLogLevelFromConfig();
        
        // 监听配置变化
        vscode.workspace.onDidChangeConfiguration((event) => {
            if (event.affectsConfiguration('codeFormatter.logLevel')) {
                this.logLevel = this.getLogLevelFromConfig();
            }
        });
    }
    
    debug(message: string, ...args: any[]): void {
        if (this.logLevel <= LogLevel.DEBUG) {
            this.log('DEBUG', message, args);
        }
    }
    
    info(message: string, ...args: any[]): void {
        if (this.logLevel <= LogLevel.INFO) {
            this.log('INFO', message, args);
        }
    }
    
    warn(message: string, ...args: any[]): void {
        if (this.logLevel <= LogLevel.WARN) {
            this.log('WARN', message, args);
        }
    }
    
    error(message: string, ...args: any[]): void {
        if (this.logLevel <= LogLevel.ERROR) {
            this.log('ERROR', message, args);
        }
    }
    
    private log(level: string, message: string, args: any[]): void {
        const timestamp = new Date().toISOString();
        const formattedMessage = args.length > 0 
            ? `${message} ${args.map(arg => JSON.stringify(arg)).join(' ')}`
            : message;
        
        const logMessage = `[${timestamp}] [${level}] ${formattedMessage}`;
        
        // 输出到通道
        this.channel.appendLine(logMessage);
        
        // 错误级别也输出到控制台
        if (level === 'ERROR') {
            console.error(logMessage);
        }
    }
    
    private getLogLevelFromConfig(): LogLevel {
        const config = vscode.workspace.getConfiguration('codeFormatter');
        const level = config.get<string>('logLevel', 'info').toUpperCase();
        
        switch (level) {
            case 'DEBUG': return LogLevel.DEBUG;
            case 'INFO': return LogLevel.INFO;
            case 'WARN': return LogLevel.WARN;
            case 'ERROR': return LogLevel.ERROR;
            case 'NONE': return LogLevel.NONE;
            default: return LogLevel.INFO;
        }
    }
    
    show(): void {
        this.channel.show();
    }
    
    dispose(): void {
        this.channel.dispose();
    }
}

3.1.10 插件清单配置

// package.json
{
  "name": "code-formatter",
  "displayName": "Advanced Code Formatter",
  "description": "支持多种语言的智能代码格式化工具",
  "version": "1.0.0",
  "publisher": "your-publisher-name",
  "engines": {
    "vscode": "^1.60.0"
  },
  "categories": [
    "Formatters",
    "Programming Languages",
    "Linters"
  ],
  "keywords": [
    "format",
    "formatter",
    "prettier",
    "beautify",
    "code style"
  ],
  "icon": "images/icon.png",
  "galleryBanner": {
    "color": "#1e1e1e",
    "theme": "dark"
  },
  "activationEvents": [
    "onStartupFinished",
    "onLanguage:javascript",
    "onLanguage:typescript",
    "onLanguage:json",
    "onLanguage:html",
    "onLanguage:css",
    "onLanguage:python"
  ],
  "main": "./dist/extension.js",
  "browser": "./dist/extension.js",
  "contributes": {
    "configuration": {
      "title": "Code Formatter",
      "properties": {
        "codeFormatter.enabled": {
          "type": "boolean",
          "default": true,
          "description": "启用/禁用代码格式化器"
        },
        "codeFormatter.formatOnSave": {
          "type": "boolean",
          "default": false,
          "description": "保存时自动格式化"
        },
        "codeFormatter.formatOnType": {
          "type": "boolean",
          "default": true,
          "description": "输入时自动格式化"
        },
        "codeFormatter.maxLineLength": {
          "type": "number",
          "default": 80,
          "description": "最大行长度"
        },
        "codeFormatter.trailingComma": {
          "type": "string",
          "enum": ["none", "es5", "all"],
          "default": "es5",
          "description": "尾随逗号规则"
        },
        "codeFormatter.semi": {
          "type": "boolean",
          "default": true,
          "description": "是否使用分号"
        },
        "codeFormatter.singleQuote": {
          "type": "boolean",
          "default": false,
          "description": "是否使用单引号"
        },
        "codeFormatter.logLevel": {
          "type": "string",
          "enum": ["debug", "info", "warn", "error", "none"],
          "default": "info",
          "description": "日志级别"
        }
      }
    },
    "commands": [
      {
        "command": "codeFormatter.formatDocument",
        "title": "Format Document",
        "category": "Formatter"
      },
      {
        "command": "codeFormatter.formatSelection",
        "title": "Format Selection",
        "category": "Formatter"
      },
      {
        "command": "codeFormatter.showOutput",
        "title": "Show Formatter Output",
        "category": "Formatter"
      }
    ],
    "keybindings": [
      {
        "command": "codeFormatter.formatDocument",
        "key": "shift+alt+f",
        "mac": "shift+option+f",
        "when": "editorTextFocus"
      },
      {
        "command": "codeFormatter.formatSelection",
        "key": "ctrl+k ctrl+f",
        "mac": "cmd+k cmd+f",
        "when": "editorTextFocus && editorHasSelection"
      }
    ],
    "menus": {
      "editor/context": [
        {
          "command": "codeFormatter.formatDocument",
          "when": "editorTextFocus",
          "group": "1_modification"
        },
        {
          "command": "codeFormatter.formatSelection",
          "when": "editorTextFocus && editorHasSelection",
          "group": "1_modification"
        }
      ],
      "commandPalette": [
        {
          "command": "codeFormatter.formatDocument",
          "when": "editorTextFocus"
        },
        {
          "command": "codeFormatter.formatSelection",
          "when": "editorTextFocus && editorHasSelection"
        }
      ]
    }
  },
  "scripts": {
    "vscode:prepublish": "npm run package",
    "compile": "webpack",
    "watch": "webpack --watch",
    "package": "webpack --mode production --devtool hidden-source-map",
    "lint": "eslint src --ext ts",
    "test": "node ./test/runTest.js",
    "publish": "vsce publish",
    "publish:minor": "vsce publish minor",
    "publish:major": "vsce publish major"
  },
  "devDependencies": {
    "@types/vscode": "^1.60.0",
    "@types/node": "16.x",
    "@typescript-eslint/eslint-plugin": "^5.1.0",
    "@typescript-eslint/parser": "^5.1.0",
    "eslint": "^8.1.0",
    "typescript": "^4.4.4",
    "ts-loader": "^9.2.6",
    "webpack": "^5.52.1",
    "webpack-cli": "^4.8.0",
    "@vscode/vsce": "^2.15.0"
  },
  "dependencies": {
    "typescript": "^4.4.4"
  },
  "repository": {
    "type": "git",
    "url": "https://github.com/yourusername/code-formatter.git"
  },
  "bugs": {
    "url": "https://github.com/yourusername/code-formatter/issues"
  },
  "homepage": "https://github.com/yourusername/code-formatter#readme",
  "license": "MIT"
}

3.1.11 Webpack配置

// webpack.config.js
const path = require('path');

module.exports = {
  target: 'node',
  mode: 'none',
  entry: './src/extension.ts',
  output: {
    path: path.resolve(__dirname, 'dist'),
    filename: 'extension.js',
    libraryTarget: 'commonjs2'
  },
  externals: {
    vscode: 'commonjs vscode'
  },
  resolve: {
    extensions: ['.ts', '.js']
  },
  module: {
    rules: [
      {
        test: /\.ts$/,
        exclude: /node_modules/,
        use: [
          {
            loader: 'ts-loader',
            options: {
              compilerOptions: {
                "module": "es6",
                "moduleResolution": "node"
              }
            }
          }
        ]
      }
    ]
  },
  devtool: 'nosources-source-map'
};

3.1.12 使用示例

// examples/test-usage.ts
import * as vscode from 'vscode';

// 在VS Code扩展中使用
async function testFormatter() {
    // 获取活动文本编辑器
    const editor = vscode.window.activeTextEditor;
    if (!editor) {
        vscode.window.showErrorMessage('没有活动的文本编辑器');
        return;
    }
    
    const document = editor.document;
    
    // 执行格式化命令
    await vscode.commands.executeCommand('codeFormatter.formatDocument');
    
    vscode.window.showInformationMessage('文档已格式化');
}

// 注册测试命令
export function activate(context: vscode.ExtensionContext) {
    const disposable = vscode.commands.registerCommand(
        'extension.testFormatter',
        testFormatter
    );
    
    context.subscriptions.push(disposable);
}

四、开发工具总结

4.1 Python插件开发工具链

必备工具:
  - Python 3.8+
  - pip/setuptools/wheel
  - virtualenv/conda
  
开发工具:
  - IDE: VS Code/PyCharm
  - 代码规范: black/flake8/mypy
  - 测试框架: pytest/pytest-cov
  - 文档生成: Sphinx
  
打包工具:
  - setuptools
  - twine (发布到PyPI)
  - PyInstaller (打包为exe)
  
监控调试:
  - logging模块
  - pdb/ipdb调试器
  - cProfile性能分析

4.2 TypeScript插件开发工具链

必备工具:
  - Node.js 16+
  - npm/yarn/pnpm
  
开发工具:
  - IDE: VS Code
  - 构建工具: Webpack/Rollup
  - 代码规范: ESLint/Prettier
  - 测试框架: Jest/Mocha
  
VS Code扩展工具:
  - yo code (项目生成器)
  - vsce (打包工具)
  - @vscode/test-electron (测试)
  
调试工具:
  - VS Code调试器
  - Chrome DevTools
  - Node.js Inspector

4.3 通用最佳实践

五、关键要点总结

5.1 Python插件开发要点

1. 清晰的接口设计：定义明确的抽象基类
2. 依赖管理：使用requirements.txt或pyproject.toml
3. 错误处理：完善的异常处理机制
4. 配置管理：支持配置文件和环境变量
5. 生命周期管理：明确的初始化、启动、停止流程

5.2 TypeScript插件开发要点

1. 类型安全：充分利用TypeScript类型系统
2. 模块化设计：合理的目录结构和模块划分
3. 异步处理：正确处理Promise和async/await
4. 事件驱动：利用VS Code的事件系统
5. 配置管理：支持工作区和用户配置

5.3 通用成功要素

1. 良好的文档：API文档、使用示例、安装说明
2. 完整的测试：单元测试、集成测试、E2E测试
3. 性能优化：内存管理、响应速度、资源占用
4. 错误恢复：优雅降级、自动恢复机制
5. 用户体验：简单易用、直观的配置选项

通过以上完整的实例和详细说明，您现在应该对如何为应用程序开发插件有了全面的理解。无论是Python还是TypeScript，关键在于：清晰的设计、良好的架构、完善的文档和持续的测试。