Claude Code 插件Development and scale

# 1. creation插件Table of Contents
mkdir claude-code-plugin-demo
cd claude-code-plugin-demo

# 2. 初始化npmproject
npm init -y

# 3. installationClaude Code插件Development依赖
npm install @claude-code/plugin-sdk --save-dev

# 4. creation插件configurationfile
echo '{"name": "claude-code-plugin-demo", "version": "1.0.0", "description": "Claude Code演示插件", "main": "index.js", "claude": {"plugin": true, "name": "Demo Plugin", "version": "1.0.0", "author": "Your Name", "description": "A demo plugin for Claude Code"}}' > package.json

# 5. creation插件入口file
echo 'const { Plugin } = require("@claude-code/plugin-sdk");

class DemoPlugin extends Plugin {
    constructor() {
        super();
        this.name = "demo-plugin";
        this.version = "1.0.0";
    }
    
    async initialize() {
        console.log("Demo plugin initialized");
    }
    
    async dispose() {
        console.log("Demo plugin disposed");
    }
}

module.exports = DemoPlugin;' > index.js

const { Plugin, EventType } = require("@claude-code/plugin-sdk");

class MyPlugin extends Plugin {
    constructor() {
        super();
        this.name = "my-plugin";
        this.version = "1.0.0";
    }
    
    async initialize() {
        console.log("My plugin initialized");
        
        // registerevent监听器
        this.eventBus.on(EventType.CODE_GENERATION_START, this.onCodeGenerationStart.bind(this));
        this.eventBus.on(EventType.CODE_GENERATION_END, this.onCodeGenerationEnd.bind(this));
        
        // registercommands
        this.commandRegistry.registerCommand("my-plugin:hello", this.helloCommand.bind(this));
        
        // register菜单项
        this.menuRegistry.registerMenuItem("My Plugin", "Say Hello", "my-plugin:hello");
    }
    
    async dispose() {
        console.log("My plugin disposed");
        // cleanresource
    }
    
    async onCodeGenerationStart(event) {
        console.log("Code generation started:", event);
    }
    
    async onCodeGenerationEnd(event) {
        console.log("Code generation ended:", event);
    }
    
    async helloCommand() {
        this.ui.showInformationMessage("Hello from My Plugin!");
    }
}

module.exports = MyPlugin;

// registercommands
this.commandRegistry.registerCommand("my-plugin:format-code", async (args) => {
    try {
        const editor = this.context.activeEditor;
        if (!editor) {
            this.ui.showErrorMessage("No active editor");
            return;
        }
        
        const selection = editor.selection;
        const text = editor.document.getText(selection);
        
        if (!text) {
            this.ui.showErrorMessage("No text selected");
            return;
        }
        
        // formatcode
        const formattedText = this.formatCode(text, editor.document.languageId);
        
        // replace选in 文本
        await editor.edit((editbuilder) => {
            editbuilder.replace(selection, formattedText);
        });
        
        this.ui.showInformationMessage("Code formatted successfully!");
    } catch (error) {
        this.ui.showErrorMessage(`Error formatting code: ${error.message}`);
    }
});

// 执行commands
await this.commandRegistry.executeCommand("my-plugin:format-code", { option: "value" });

const { Plugin } = require("@claude-code/plugin-sdk");
const prettier = require("prettier");

class CodeFormatterPlugin extends Plugin {
    constructor() {
        super();
        this.name = "code-formatter";
        this.version = "1.0.0";
    }
    
    async initialize() {
        console.log("Code formatter plugin initialized");
        
        // registercommands
        this.commandRegistry.registerCommand("code-formatter:format", this.formatCode.bind(this));
        this.commandRegistry.registerCommand("code-formatter:format-all", this.formatAllCode.bind(this));
        
        // register菜单项
        this.menuRegistry.registerMenuItem("Code Formatter", "Format Selection", "code-formatter:format");
        this.menuRegistry.registerMenuItem("Code Formatter", "Format All", "code-formatter:format-all");
    }
    
    async formatCode() {
        try {
            const editor = this.context.activeEditor;
            if (!editor) {
                this.ui.showErrorMessage("No active editor");
                return;
            }
            
            const selection = editor.selection;
            const text = editor.document.getText(selection);
            
            if (!text) {
                this.ui.showErrorMessage("No text selected");
                return;
            }
            
            const formattedText = await this.format(text, editor.document.languageId);
            
            await editor.edit((editbuilder) => {
                editbuilder.replace(selection, formattedText);
            });
            
            this.ui.showInformationMessage("Code formatted successfully!");
        } catch (error) {
            this.ui.showErrorMessage(`Error formatting code: ${error.message}`);
        }
    }
    
    async formatAllCode() {
        try {
            const editor = this.context.activeEditor;
            if (!editor) {
                this.ui.showErrorMessage("No active editor");
                return;
            }
            
            const text = editor.document.getText();
            const formattedText = await this.format(text, editor.document.languageId);
            
            await editor.edit((editbuilder) => {
                const start = editor.document.positionAt(0);
                const end = editor.document.positionAt(text.length);
                editbuilder.replace(new Range(start, end), formattedText);
            });
            
            this.ui.showInformationMessage("All code formatted successfully!");
        } catch (error) {
            this.ui.showErrorMessage(`Error formatting code: ${error.message}`);
        }
    }
    
    async format(text, language) {
        const parser = this.getParserForLanguage(language);
        if (!parser) {
            throw new Error(`Unsupported language: ${language}`);
        }
        
        return prettier.format(text, {
            parser,
            semi: true,
            singleQuote: true,
            trailingComma: "es5",
            tabWidth: 2,
        });
    }
    
    getParserForLanguage(language) {
        const parsers = {
            javascript: "babel",
            typescript: "typescript",
            html: "html",
            css: "css",
            json: "json",
            markdown: "markdown",
        };
        return parsers[language];
    }
}

module.exports = CodeFormatterPlugin;

const { Plugin } = require("@claude-code/plugin-sdk");
const { execSync } = require("child_process");

class GitIntegrationPlugin extends Plugin {
    constructor() {
        super();
        this.name = "git-integration";
        this.version = "1.0.0";
    }
    
    async initialize() {
        console.log("Git integration plugin initialized");
        
        // registercommands
        this.commandRegistry.registerCommand("git-integration:status", this.gitStatus.bind(this));
        this.commandRegistry.registerCommand("git-integration:submitting", this.gitCommit.bind(this));
        this.commandRegistry.registerCommand("git-integration:push", this.gitPush.bind(this));
        this.commandRegistry.registerCommand("git-integration:pull", this.gitPull.bind(this));
        
        // register菜单项
        this.menuRegistry.registerMenuItem("Git", "Status", "git-integration:status");
        this.menuRegistry.registerMenuItem("Git", "Commit", "git-integration:submitting");
        this.menuRegistry.registerMenuItem("Git", "Push", "git-integration:push");
        this.menuRegistry.registerMenuItem("Git", "Pull", "git-integration:pull");
    }
    
    async gitStatus() {
        try {
            const result = this.executeGitCommand("status");
            this.ui.showInformationMessage(`Git status:\n${result}`);
        } catch (error) {
            this.ui.showErrorMessage(`Error executing git status: ${error.message}`);
        }
    }
    
    async gitCommit() {
        try {
            const message = await this.ui.showInputBox({ prompt: "Enter submitting message" });
            if (!message) return;
            
            this.executeGitCommand(`add .`);
            const result = this.executeGitCommand(`submitting -m "${message}"`);
            this.ui.showInformationMessage(`Git submitting result:\n${result}`);
        } catch (error) {
            this.ui.showErrorMessage(`Error executing git submitting: ${error.message}`);
        }
    }
    
    async gitPush() {
        try {
            const result = this.executeGitCommand("push");
            this.ui.showInformationMessage(`Git push result:\n${result}`);
        } catch (error) {
            this.ui.showErrorMessage(`Error executing git push: ${error.message}`);
        }
    }
    
    async gitPull() {
        try {
            const result = this.executeGitCommand("pull");
            this.ui.showInformationMessage(`Git pull result:\n${result}`);
        } catch (error) {
            this.ui.showErrorMessage(`Error executing git pull: ${error.message}`);
        }
    }
    
    executeGitCommand(command) {
        try {
            return execSync(`git ${command}`, { 
                cwd: this.context.workspaceRoot, 
                encoding: "utf8"
            });
        } catch (error) {
            throw new Error(error.stdout || error.stderr || error.message);
        }
    }
}

module.exports = GitIntegrationPlugin;

// package.json in testconfiguration
{
    "scripts": {
        "test": "jest",
        "test:watch": "jest --watch",
        "test:coverage": "jest --coverage"
    },
    "devDependencies": {
        "jest": "^29.0.0",
        "@claude-code/plugin-sdk": "^1.0.0"
    }
}

// testfileexample (test/plugin.test.js)
const MyPlugin = require("../index");

describe("MyPlugin", () => {
    let plugin;
    
    beforeEach(() => {
        plugin = new MyPlugin();
    });
    
    test("should initialize plugin", async () => {
        // Mock dependencies
        plugin.context = {
            activeEditor: null,
            workspaceRoot: "./"
        };
        
        plugin.eventBus = {
            on: jest.fn()
        };
        
        plugin.commandRegistry = {
            registerCommand: jest.fn()
        };
        
        plugin.menuRegistry = {
            registerMenuItem: jest.fn()
        };
        
        await plugin.initialize();
        expect(plugin.commandRegistry.registerCommand).toHaveBeenCalledWith(
            "my-plugin:hello",
            expect.any(Function)
        );
    });
    
    test("should dispose plugin", async () => {
        await plugin.dispose();
        // Add assertions here
    });
});

# 1. 构建插件
npm run build

# 2. 打package插件
npm run package

# 3. release to GitHub
# creationGitHubrelease
#  on 传打package 插件file

# 4. release to Claude Code插件市场
# loginClaude Code插件市场
# 填写插件information
#  on 传插件package
# submitting审核