lint-tools-sdk 1.0.0

package/README.md

@@ -0,0 +1,371 @@
+# Lint Tools SDK
+
+一个用于在多个Git仓库中统一代码质量管理的前端代码规范工具SDK（npm包形式）。
+
+## 核心功能
+
+- ✅ **ESLint集成**：支持ESLint v9+ flat config格式，实现代码格式化校验
+- ✅ **commitlint集成**：提交信息规范校验，确保提交信息格式统一
+- ✅ **Git Hooks自动触发**：通过husky在提交代码时自动对暂存文件进行格式化校验
+- ✅ **lint-staged**：仅对Git暂存文件执行ESLint校验与修复
+- ✅ **配置覆盖机制**：项目级配置自动合并覆盖SDK默认配置
+- ✅ **CLI命令支持**：提供丰富的命令行工具，方便使用和集成
+
+## 安装
+
+```bash
+# 全局安装（可选）
+npm install -g lint-tools-sdk
+
+# 局部安装
+npm install --save-dev lint-tools-sdk
+```
+
+## 快速开始
+
+### 1. 初始化项目
+
+在项目根目录下执行：
+
+```bash
+npx lint-tools-sdk init
+```
+
+此命令会：
+- 安装Git Hooks（pre-commit和commit-msg）
+- 创建默认配置文件（eslint.config.js、.commitlintrc.js、.lintstagedrc.js）
+- 更新package.json脚本
+
+### 2. 基本使用
+
+#### 代码校验
+
+```bash
+# 全量代码校验
+npx lint-tools-sdk lint
+
+# 自动修复代码问题
+npx lint-tools-sdk lint:fix
+
+# 仅校验暂存文件
+npx lint-tools-sdk lint:staged
+```
+
+#### 提交信息校验
+
+```bash
+# 校验提交信息
+npx lint-tools-sdk commitlint "feat: add new feature"
+
+# 使用git commit时会自动触发校验
+```
+
+#### 查看诊断信息
+
+```bash
+# 查看当前配置和服务状态
+npx lint-tools-sdk status
+```
+
+## 配置说明
+
+### 1. 项目级配置
+
+可以通过以下方式覆盖SDK的默认配置：
+
+#### a) package.json中的lintToolsConfig
+
+```json
+{
+  "lintToolsConfig": {
+    "eslint": {
+      "enabled": true,
+      "fix": true
+    },
+    "commitlint": {
+      "enabled": true
+    },
+    "githooks": {
+      "enabled": true
+    },
+    "lintStaged": {
+      "enabled": true
+    }
+  }
+}
+```
+
+#### b) .linttoolsrc.js配置文件
+
+```javascript
+module.exports = {
+  eslint: {
+    enabled: true,
+    fix: true
+  },
+  commitlint: {
+    enabled: true
+  },
+  githooks: {
+    enabled: true
+  },
+  lintStaged: {
+    enabled: true
+  }
+};
+```
+
+### 2. ESLint配置
+
+SDK使用ESLint v9+的flat config格式，默认配置文件为`eslint.config.js`：
+
+```javascript
+import globals from "globals";
+import pluginJs from "@eslint/js";
+
+export default [
+  {
+    files: ["**/*.js"],
+    languageOptions: {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      globals: {
+        ...globals.node,
+        ...globals.browser
+      }
+    },
+    rules: {
+      ...pluginJs.configs.recommended.rules,
+      // 项目自定义规则
+    }
+  }
+];
+```
+
+### 3. commitlint配置
+
+默认配置文件为`.commitlintrc.js`：
+
+```javascript
+module.exports = {
+  extends: ['@commitlint/config-conventional']
+};
+```
+
+### 4. lint-staged配置
+
+默认配置文件为`.lintstagedrc.js`：
+
+```javascript
+module.exports = {
+  '*.js': ['eslint --fix', 'git add'],
+  '*.jsx': ['eslint --fix', 'git add'],
+  '*.ts': ['eslint --fix', 'git add'],
+  '*.tsx': ['eslint --fix', 'git add']
+};
+```
+
+## CLI命令
+
+| 命令 | 描述 |
+|------|------|
+| `init` | 初始化项目，安装Git Hooks并创建默认配置 |
+| `lint` | 全量代码校验 |
+| `lint:fix` | 自动修复代码问题 |
+| `lint:staged` | 仅校验暂存文件 |
+| `commitlint <message>` | 校验提交信息格式 |
+| `status` | 查看当前配置和服务状态 |
+
+## Git Hooks
+
+### pre-commit
+
+执行lint-staged，对暂存文件进行ESLint校验与修复：
+
+```bash
+npx lint-staged
+```
+
+### commit-msg
+
+执行commitlint，校验提交信息格式：
+
+```bash
+npx commitlint --edit "$1"
+```
+
+## 项目结构
+
+```
+lint-tools-sdk/
+├── src/
+│   ├── index.js          # SDK主入口和CLI命令处理
+│   ├── eslint.js         # ESLint服务实现
+│   ├── commitlint.js     # commitlint服务实现
+│   └── githooks.js       # Git Hooks服务实现
+├── package.json
+└── README.md
+```
+
+## 模块化架构
+
+### 1. LintToolsSDK (主类)
+
+整合所有服务，提供统一的API和CLI接口。
+
+### 2. ESLintService
+
+- 配置加载与管理
+- 文件校验与修复
+- 暂存文件处理
+
+### 3. CommitLintService
+
+- 提交信息校验
+- 配置文件管理
+
+### 4. GitHooksService
+
+- husky钩子安装与管理
+- 钩子脚本生成
+
+## 技术栈
+
+- **Node.js**：运行环境
+- **ESLint v9+**：代码质量检查
+- **commitlint**：提交信息规范
+- **husky**：Git Hooks管理
+- **lint-staged**：暂存文件处理
+
+## 兼容性
+
+- **ESLint**：^9.0.0
+- **husky**：^8.0.0 || ^9.0.0
+- **lint-staged**：^15.0.0 || ^16.0.0
+
+## 项目构建与发布
+
+### 1. 构建项目
+
+```bash
+# 安装依赖
+npm install
+
+# 验证代码（检查语法和类型错误）
+npm run lint
+
+# 运行测试（如有）
+npm run test
+```
+
+### 2. 发布到npm
+
+```bash
+# 确保已登录npm
+npm login
+
+# 更新版本号（根据语义化版本规范）
+npm version patch  # 修复bug，版本号第三位加1
+npm version minor  # 新增功能，版本号第二位加1
+npm version major  # 大版本更新，版本号第一位加1
+
+# 发布到npm
+npm publish
+```
+
+## 在其他项目中使用与验证
+
+### 1. 安装SDK
+
+```bash
+# 从npm安装
+npm install --save-dev lint-tools-sdk
+
+# 或从本地开发版本安装
+npm install --save-dev ../path/to/lint-tools-sdk
+```
+
+### 2. 初始化配置
+
+```bash
+npx lint-tools-sdk init
+```
+
+### 3. 验证功能
+
+#### a) 代码校验
+
+```bash
+# 创建一个包含错误的测试文件
+echo "const a = 1 console.log(a)" > test.js
+
+# 执行代码校验，应该能检测到错误
+npx lint-tools-sdk lint
+
+# 尝试自动修复
+npx lint-tools-sdk lint:fix
+```
+
+#### b) 提交信息校验
+
+```bash
+# 测试正确的提交信息（应该通过）
+npx lint-tools-sdk commitlint "feat: add new feature"
+
+# 测试错误的提交信息（应该失败）
+npx lint-tools-sdk commitlint "add new feature"
+```
+
+#### c) Git Hooks验证
+
+```bash
+# 将测试文件添加到暂存区
+git add test.js
+
+# 尝试提交（应该触发pre-commit钩子）
+git commit -m "fix: update test file"
+```
+
+## 贡献
+
+欢迎提交Issue和Pull Request！
+
+## 许可证
+
+ISC
+
+## 项目构建与发布
+
+### 发布说明
+该项目是一个Node.js SDK，主要包含JavaScript源代码，**不需要**使用webpack、rollup等工具进行打包。由于项目结构简单，直接发布源代码即可正常工作。
+
+### 确保发布内容正确
+通过以下配置确保只发布必要的文件：
+1. `.gitignore`：排除node_modules、test-project等非必要文件
+2. `package.json`的`files`字段：明确指定需要发布的文件和目录
+
+### 发布步骤
+1. 更新版本号：
+   ```bash
+   npm version patch  # 或 minor/major
+   ```
+
+2. 登录npm：
+   ```bash
+   npm login
+   ```
+
+3. 发布到npm：
+   ```bash
+   npm publish
+   ```
+
+4. （可选）发布前验证：
+   ```bash
+   # 查看将被发布的文件
+   npm pack --dry-run
+   
+   # 或生成tgz包检查内容
+   npm pack
+   tar -tf lint-tools-sdk-*.tgz
+   ```

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "lint-tools-sdk",
+  "version": "1.0.0",
+  "description": "A linting tools SDK for consistent code quality across multiple git repositories",
+  "main": "src/index.js",
+  "bin": {
+    "lint-tools-sdk": "src/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepare": "husky install"
+  },
+  "keywords": ["eslint", "commitlint", "git-hooks", "linting", "code-quality"],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@commitlint/cli": "^20.2.0",
+    "@commitlint/config-conventional": "^20.2.0",
+    "@eslint/js": "^9.39.2",
+    "eslint": "^9.39.2",
+    "globals": "^16.0.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7"
+  },
+  "peerDependencies": {
+    "eslint": "^7.0.0 || ^8.0.0 || ^9.0.0",
+    "husky": "^8.0.0 || ^9.0.0",
+    "lint-staged": "^15.0.0 || ^16.0.0"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "package.json"
+  ]
+}

package/src/commitlint.js

@@ -0,0 +1,110 @@
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+class CommitLintService {
+  constructor(options = {}) {
+    this.options = options;
+    this.projectRoot = options.projectRoot || process.cwd();
+  }
+
+  findCommitlintConfig() {
+    const configFiles = [
+      '.commitlintrc.js',
+      '.commitlintrc.cjs',
+      '.commitlintrc.yaml',
+      '.commitlintrc.yml',
+      '.commitlintrc.json',
+      'package.json'
+    ];
+
+    for (const configFile of configFiles) {
+      const filePath = path.join(this.projectRoot, configFile);
+      if (fs.existsSync(filePath)) {
+        if (configFile === 'package.json') {
+          const packageJson = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+          if (packageJson.commitlint) {
+            return filePath;
+          }
+        } else {
+          return filePath;
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  lintCommitMessage(message) {
+    try {
+      const configPath = this.findCommitlintConfig();
+      
+      if (!configPath) {
+        console.error('No commitlint configuration found');
+        return { success: false };
+      }
+      
+      // Use temporary file to avoid pipe/quoting issues on Windows
+      const tempFile = path.join(this.projectRoot, '.temp_commit_message.txt');
+      fs.writeFileSync(tempFile, message);
+      
+      try {
+        const result = execSync(
+          `npx commitlint --edit "${tempFile}"`,
+          { stdio: ['pipe', 'pipe', 'pipe'], cwd: this.projectRoot }
+        );
+        
+        return { success: true, output: result.toString() };
+      } finally {
+        // Clean up temporary file
+        if (fs.existsSync(tempFile)) {
+          fs.unlinkSync(tempFile);
+        }
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error.stderr ? error.stderr.toString() : error.message,
+        output: error.stderr ? error.stderr.toString() : error.message
+      };
+    }
+  }
+
+  lintCommitFromFile(filePath) {
+    try {
+      const commitMessage = fs.readFileSync(filePath, 'utf8');
+      return this.lintCommitMessage(commitMessage);
+    } catch (error) {
+      console.error('Failed to read commit message file:', error);
+      return { success: false, error: error.message };
+    }
+  }
+
+  createDefaultConfig() {
+    const configPath = path.join(this.projectRoot, '.commitlintrc.js');
+    
+    if (!fs.existsSync(configPath)) {
+      const defaultConfig = `module.exports = {
+  extends: ['@commitlint/config-conventional']
+};`;
+      
+      fs.writeFileSync(configPath, defaultConfig);
+      console.log('Created default .commitlintrc.js');
+      return configPath;
+    }
+    
+    return configPath;
+  }
+
+  // Get commitlint version info
+  getVersion() {
+    try {
+      const version = execSync('npx commitlint --version', { encoding: 'utf8', cwd: this.projectRoot });
+      return version.trim();
+    } catch {
+      return null;
+    }
+  }
+}
+
+module.exports = CommitLintService;

package/src/eslint.js

@@ -0,0 +1,138 @@
+const { ESLint } = require('eslint');
+const path = require('path');
+const fs = require('fs');
+
+class ESLintService {
+  constructor(options = {}) {
+    this.options = options;
+    this.projectRoot = options.projectRoot || process.cwd();
+  }
+
+  async createESLintInstance() {
+    // For ESLint v9, we use flat config format
+    const eslint = new ESLint({
+      fix: this.options.fix || false
+    });
+    
+    return eslint;
+  }
+
+  findESLintConfig() {
+    // ESLint v9 uses eslint.config.* files
+    const configFiles = [
+      'eslint.config.js',
+      'eslint.config.cjs',
+      'eslint.config.mjs',
+      '.eslintrc.js',
+      '.eslintrc.cjs',
+      '.eslintrc.yaml',
+      '.eslintrc.yml',
+      '.eslintrc.json',
+      'package.json'
+    ];
+
+    for (const configFile of configFiles) {
+      const filePath = path.join(this.projectRoot, configFile);
+      if (fs.existsSync(filePath)) {
+        if (configFile === 'package.json') {
+          const packageJson = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+          if (packageJson.eslintConfig) {
+            return filePath;
+          }
+        } else {
+          return filePath;
+        }
+      }
+    }
+    
+    return null;
+  }
+
+  async lintFiles(files) {
+    try {
+      const eslint = await this.createESLintInstance();
+      const results = await eslint.lintFiles(files);
+      
+      // Fix and write changes if requested
+      if (this.options.fix) {
+        await ESLint.outputFixes(results);
+      }
+      
+      // Format results for output
+      const formatter = await eslint.loadFormatter('stylish');
+      const resultText = formatter.format(results);
+      
+      // Check if there are any errors
+      const hasErrors = results.some(result => result.errorCount > 0);
+      
+      return {
+        success: !hasErrors,
+        results: results,
+        output: resultText
+      };
+    } catch (error) {
+      console.error('ESLint failed:', error);
+      return {
+        success: false,
+        error: error.message,
+        output: `ESLint error: ${error.message}`
+      };
+    }
+  }
+
+  async lintStagedFiles() {
+    const lintStagedConfig = this.findLintStagedConfig();
+    
+    if (!lintStagedConfig) {
+      console.error('No lint-staged configuration found');
+      return { success: false };
+    }
+    
+    try {
+      // Get staged files using git
+      const { execSync } = require('child_process');
+      const stagedFiles = execSync('git diff --name-only --cached', { encoding: 'utf8' })
+        .trim()
+        .split('\n')
+        .filter(Boolean);
+      
+      if (stagedFiles.length === 0) {
+        return { success: true, output: 'No staged files to lint' };
+      }
+      
+      return await this.lintFiles(stagedFiles);
+    } catch (error) {
+      console.error('Failed to get staged files:', error);
+      return { success: false, error: error.message };
+    }
+  }
+
+  findLintStagedConfig() {
+    const configFiles = [
+      '.lintstagedrc.js',
+      '.lintstagedrc.cjs',
+      '.lintstagedrc.yaml',
+      '.lintstagedrc.yml',
+      '.lintstagedrc.json',
+      'package.json'
+    ];
+
+    for (const configFile of configFiles) {
+      const filePath = path.join(this.projectRoot, configFile);
+      if (fs.existsSync(filePath)) {
+        if (configFile === 'package.json') {
+          const packageJson = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+          if (packageJson['lint-staged']) {
+            return packageJson['lint-staged'];
+          }
+        } else {
+          return require(filePath);
+        }
+      }
+    }
+    
+    return null;
+  }
+}
+
+module.exports = ESLintService;

package/src/githooks.js

@@ -0,0 +1,190 @@
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+class GitHooksService {
+  constructor(options = {}) {
+    this.options = options;
+    this.projectRoot = options.projectRoot || process.cwd();
+    this.huskyDir = path.join(this.projectRoot, '.husky');
+  }
+
+  // Initialize husky
+  initHusky() {
+    try {
+      execSync('npx husky install', { stdio: 'inherit', cwd: this.projectRoot });
+      console.log('Husky initialized successfully');
+      return true;
+    } catch (error) {
+      console.error('Failed to initialize husky:', error);
+      return false;
+    }
+  }
+
+  // Install pre-commit hook
+  installPreCommitHook(script = null) {
+    try {
+      const hookScript = script || this.getDefaultPreCommitScript();
+      const hookPath = path.join(this.huskyDir, 'pre-commit');
+      
+      // Ensure husky directory exists
+      if (!fs.existsSync(this.huskyDir)) {
+        if (!this.initHusky()) {
+          return false;
+        }
+      }
+      
+      // Write and make executable
+      fs.writeFileSync(hookPath, hookScript);
+      fs.chmodSync(hookPath, '755');
+      
+      console.log('Pre-commit hook installed successfully');
+      return true;
+    } catch (error) {
+      console.error('Failed to install pre-commit hook:', error);
+      return false;
+    }
+  }
+
+  // Install commit-msg hook
+  installCommitMsgHook(script = null) {
+    try {
+      const hookScript = script || this.getDefaultCommitMsgScript();
+      const hookPath = path.join(this.huskyDir, 'commit-msg');
+      
+      // Ensure husky directory exists
+      if (!fs.existsSync(this.huskyDir)) {
+        if (!this.initHusky()) {
+          return false;
+        }
+      }
+      
+      // Write and make executable
+      fs.writeFileSync(hookPath, hookScript);
+      fs.chmodSync(hookPath, '755');
+      
+      console.log('Commit-msg hook installed successfully');
+      return true;
+    } catch (error) {
+      console.error('Failed to install commit-msg hook:', error);
+      return false;
+    }
+  }
+
+  // Install all required hooks
+  installAllHooks() {
+    const preCommitSuccess = this.installPreCommitHook();
+    const commitMsgSuccess = this.installCommitMsgHook();
+    
+    return preCommitSuccess && commitMsgSuccess;
+  }
+
+  // Default pre-commit hook script
+  getDefaultPreCommitScript() {
+    return `npx lint-staged`;
+  }
+
+  // Default commit-msg hook script
+  getDefaultCommitMsgScript() {
+    return `npx commitlint --edit "$1"`;
+  }
+
+  // Uninstall a hook
+  uninstallHook(hookName) {
+    try {
+      const hookPath = path.join(this.huskyDir, hookName);
+      
+      if (fs.existsSync(hookPath)) {
+        fs.unlinkSync(hookPath);
+        console.log(`${hookName} hook uninstalled successfully`);
+        return true;
+      } else {
+        console.log(`${hookName} hook not found`);
+        return false;
+      }
+    } catch (error) {
+      console.error(`Failed to uninstall ${hookName} hook:`, error);
+      return false;
+    }
+  }
+
+  // List installed hooks
+  listHooks() {
+    try {
+      if (!fs.existsSync(this.huskyDir)) {
+        console.log('No husky hooks directory found');
+        return [];
+      }
+      
+      const hooks = fs.readdirSync(this.huskyDir)
+        .filter(file => file !== '_' && fs.statSync(path.join(this.huskyDir, file)).isFile());
+      
+      console.log('Installed hooks:', hooks);
+      return hooks;
+    } catch (error) {
+      console.error('Failed to list hooks:', error);
+      return [];
+    }
+  }
+
+  // Update package.json with prepare script
+  updatePrepareScript() {
+    try {
+      const packageJsonPath = path.join(this.projectRoot, 'package.json');
+      
+      if (fs.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        
+        packageJson.scripts = packageJson.scripts || {};
+        
+        // Only add prepare script if it doesn't exist
+        if (!packageJson.scripts.prepare) {
+          packageJson.scripts.prepare = 'husky install';
+          fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+          console.log('Added prepare script to package.json');
+          return true;
+        }
+        
+        // Check if existing prepare script already includes husky install
+        if (packageJson.scripts.prepare.includes('husky install')) {
+          console.log('Prepare script already includes husky install');
+          return true;
+        }
+        
+        // Append husky install to existing prepare script
+        packageJson.scripts.prepare += ' && husky install';
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        console.log('Updated prepare script to include husky install');
+        return true;
+      } else {
+        console.error('package.json not found');
+        return false;
+      }
+    } catch (error) {
+      console.error('Failed to update prepare script:', error);
+      return false;
+    }
+  }
+
+  // Check if git repository
+  isGitRepository() {
+    try {
+      execSync('git rev-parse --is-inside-work-tree', { stdio: 'ignore', cwd: this.projectRoot });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // Get current git branch
+  getCurrentBranch() {
+    try {
+      const branch = execSync('git symbolic-ref --short HEAD', { encoding: 'utf8', cwd: this.projectRoot });
+      return branch.trim();
+    } catch {
+      return null;
+    }
+  }
+}
+
+module.exports = GitHooksService;

package/src/index.js

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Import service modules
+const ESLintService = require('./eslint');
+const CommitLintService = require('./commitlint');
+const GitHooksService = require('./githooks');
+
+class LintToolsSDK {
+  constructor(options = {}) {
+    this.options = options;
+    this.projectRoot = process.cwd();
+    this.sdkRoot = path.resolve(__dirname, '..');
+    
+    // Initialize service instances
+    this.eslintService = new ESLintService({ projectRoot: this.projectRoot, ...options.eslint });
+    this.commitLintService = new CommitLintService({ projectRoot: this.projectRoot, ...options.commitlint });
+    this.gitHooksService = new GitHooksService({ projectRoot: this.projectRoot, ...options.githooks });
+    
+    // Load configuration (project config overrides SDK defaults)
+    this.config = this.loadConfig();
+  }
+
+  // Load configuration with project-level overrides
+  loadConfig() {
+    const sdkConfig = {
+      eslint: {
+        enabled: true,
+        configFile: null,
+        fix: true
+      },
+      commitlint: {
+        enabled: true,
+        configFile: null
+      },
+      githooks: {
+        enabled: true,
+        preCommit: true,
+        commitMsg: true
+      },
+      lintStaged: {
+        enabled: true,
+        configFile: null
+      }
+    };
+
+    // Load project-level config from package.json
+    const packageJsonPath = path.join(this.projectRoot, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        if (packageJson.lintToolsConfig) {
+          // Merge project config with SDK defaults
+          this.mergeConfig(sdkConfig, packageJson.lintToolsConfig);
+        }
+      } catch (error) {
+        console.warn('Failed to load project config from package.json:', error);
+      }
+    }
+
+    // Load dedicated config file if exists
+    const configFilePath = path.join(this.projectRoot, '.linttoolsrc.js');
+    if (fs.existsSync(configFilePath)) {
+      try {
+        const projectConfig = require(configFilePath);
+        this.mergeConfig(sdkConfig, projectConfig);
+      } catch (error) {
+        console.warn('Failed to load project config from .linttoolsrc.js:', error);
+      }
+    }
+
+    // Merge with constructor options
+    this.mergeConfig(sdkConfig, this.options);
+
+    return sdkConfig;
+  }
+
+  // Deep merge two configurations
+  mergeConfig(target, source) {
+    for (const key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
+          if (!target[key]) {
+            target[key] = {};
+          }
+          this.mergeConfig(target[key], source[key]);
+        } else {
+          target[key] = source[key];
+        }
+      }
+    }
+  }
+
+  async init() {
+    console.log('Initializing Lint Tools SDK...');
+    
+    // Install Git hooks
+    if (this.config.githooks.enabled) {
+      await this.installHooks();
+    }
+
+    // Create default configs if enabled
+    if (this.config.eslint.enabled || this.config.commitlint.enabled) {
+      this.createDefaultConfigs();
+    }
+
+    // Update package scripts
+    this.updatePackageScripts();
+
+    console.log('Lint Tools SDK initialized successfully!');
+    return true;
+  }
+
+  async installHooks() {
+    try {
+      const success = this.gitHooksService.installAllHooks();
+      if (success) {
+        console.log('All Git hooks installed successfully!');
+        return true;
+      } else {
+        console.error('Failed to install some Git hooks');
+        return false;
+      }
+    } catch (error) {
+      console.error('Failed to install Git hooks:', error);
+      throw error;
+    }
+  }
+
+  createDefaultConfigs() {
+    console.log('Creating default configurations (if not exist)...');
+    
+    // Create default eslint config if not exists and enabled
+    if (this.config.eslint.enabled) {
+      // ESLint v9 uses eslint.config.js format
+      const eslintConfigPath = path.join(this.projectRoot, 'eslint.config.js');
+      if (!fs.existsSync(eslintConfigPath)) {
+        const defaultEslintConfig = `// ESLint v9 configuration
+import globals from "globals";
+import pluginJs from "@eslint/js";
+
+export default [
+  {
+    files: ["**/*.js"],
+    languageOptions: {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      globals: {
+        ...globals.node,
+        ...globals.browser
+      }
+    },
+    rules: {
+      ...pluginJs.configs.recommended.rules,
+      // Add your project-specific rules here
+    }
+  }
+];`;
+        fs.writeFileSync(eslintConfigPath, defaultEslintConfig);
+        console.log('Created default eslint.config.js');
+      } else {
+        console.log('Using existing eslint.config.js');
+      }
+    }
+
+    // Create default commitlint config if not exists and enabled
+    if (this.config.commitlint.enabled) {
+      this.commitLintService.createDefaultConfig();
+    }
+
+    // Create default lint-staged config if not exists and enabled
+    if (this.config.lintStaged.enabled) {
+      const lintStagedConfigPath = path.join(this.projectRoot, '.lintstagedrc.js');
+      if (!fs.existsSync(lintStagedConfigPath)) {
+        const defaultLintStagedConfig = `module.exports = {
+  '*.js': ['eslint --fix', 'git add'],
+  '*.jsx': ['eslint --fix', 'git add'],
+  '*.ts': ['eslint --fix', 'git add'],
+  '*.tsx': ['eslint --fix', 'git add']
+};`;
+        fs.writeFileSync(lintStagedConfigPath, defaultLintStagedConfig);
+        console.log('Created default .lintstagedrc.js');
+      } else {
+        console.log('Using existing .lintstagedrc.js');
+      }
+    }
+  }
+
+  updatePackageScripts() {
+    const packageJsonPath = path.join(this.projectRoot, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      
+      // Add or update scripts
+      packageJson.scripts = packageJson.scripts || {};
+      
+      if (this.config.eslint.enabled) {
+        packageJson.scripts.lint = packageJson.scripts.lint || 'eslint .';
+        packageJson.scripts['lint:fix'] = packageJson.scripts['lint:fix'] || 'eslint . --fix';
+      }
+      
+      if (this.config.githooks.enabled) {
+        packageJson.scripts['prepare'] = packageJson.scripts['prepare'] || 'husky install';
+      }
+      
+      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+      console.log('Updated package.json scripts');
+    }
+  }
+
+  async runLint() {
+    try {
+      if (!this.config.eslint.enabled) {
+        console.log('ESLint is disabled in configuration');
+        return true;
+      }
+      
+      const result = await this.eslintService.lintFiles(['.']);
+      console.log(result.output);
+      return result.success;
+    } catch (error) {
+      console.error('Lint failed!', error);
+      return false;
+    }
+  }
+
+  async runLintFix() {
+    try {
+      if (!this.config.eslint.enabled) {
+        console.log('ESLint is disabled in configuration');
+        return true;
+      }
+      
+      // Temporarily enable fix option
+      const originalFixOption = this.eslintService.options.fix;
+      this.eslintService.options.fix = true;
+      
+      const result = await this.eslintService.lintFiles(['.']);
+      console.log(result.output);
+      
+      // Restore original fix option
+      this.eslintService.options.fix = originalFixOption;
+      
+      return result.success;
+    } catch (error) {
+      console.error('Lint fix failed!', error);
+      return false;
+    }
+  }
+
+  async runLintStaged() {
+    try {
+      if (!this.config.eslint.enabled || !this.config.lintStaged.enabled) {
+        console.log('ESLint or lint-staged is disabled in configuration');
+        return true;
+      }
+      
+      const result = await this.eslintService.lintStagedFiles();
+      console.log(result.output);
+      return result.success;
+    } catch (error) {
+      console.error('Lint staged failed!', error);
+      return false;
+    }
+  }
+
+  runCommitLint(commitMessage) {
+    try {
+      if (!this.config.commitlint.enabled) {
+        console.log('Commitlint is disabled in configuration');
+        return true;
+      }
+      
+      const result = this.commitLintService.lintCommitMessage(commitMessage);
+      if (result.output) {
+        console.log(result.output);
+      }
+      return result.success;
+    } catch (error) {
+      console.error('Commit message lint failed!', error);
+      return false;
+    }
+  }
+
+  runCommitLintFromFile(filePath) {
+    try {
+      if (!this.config.commitlint.enabled) {
+        console.log('Commitlint is disabled in configuration');
+        return true;
+      }
+      
+      const result = this.commitLintService.lintCommitFromFile(filePath);
+      if (result.output) {
+        console.log(result.output);
+      }
+      return result.success;
+    } catch (error) {
+      console.error('Commit message lint from file failed!', error);
+      return false;
+    }
+  }
+
+  // Get diagnostic information about the current configuration
+  getDiagnostics() {
+    return {
+      projectRoot: this.projectRoot,
+      sdkRoot: this.sdkRoot,
+      config: this.config,
+      services: {
+        eslint: {
+          configFile: this.eslintService.findESLintConfig(),
+          version: this.getESLintVersion()
+        },
+        commitlint: {
+          configFile: this.commitLintService.findCommitlintConfig(),
+          version: this.commitLintService.getVersion()
+        },
+        githooks: {
+          hooks: this.gitHooksService.listHooks(),
+          huskyDir: this.gitHooksService.huskyDir
+        }
+      }
+    };
+  }
+
+  // Helper to get ESLint version
+  getESLintVersion() {
+    try {
+      const version = execSync('npx eslint --version', { encoding: 'utf8', cwd: this.projectRoot });
+      return version.trim();
+    } catch {
+      return null;
+    }
+  }
+}
+
+module.exports = LintToolsSDK;
+
+// CLI entry point
+if (require.main === module) {
+  const sdk = new LintToolsSDK();
+  const command = process.argv[2];
+  const args = process.argv.slice(3);
+  
+  // Wrap async commands in IIFE for proper async handling
+  (async () => {
+    try {
+      switch (command) {
+        case 'init':
+          await sdk.init();
+          break;
+        case 'lint': {
+          const lintSuccess = await sdk.runLint();
+          process.exit(lintSuccess ? 0 : 1);
+          break;
+        }
+        case 'lint:fix': {
+          const fixSuccess = await sdk.runLintFix();
+          process.exit(fixSuccess ? 0 : 1);
+          break;
+        }
+        case 'lint:staged': {
+          const stagedSuccess = await sdk.runLintStaged();
+          process.exit(stagedSuccess ? 0 : 1);
+          break;
+        }
+        case 'commitlint': {
+          if (args.length === 0) {
+            console.error('Error: Commit message is required');
+            console.log('Usage: npx lint-tools-sdk commitlint "your commit message"');
+            process.exit(1);
+          }
+          const commitLintSuccess = sdk.runCommitLint(args.join(' '));
+          process.exit(commitLintSuccess ? 0 : 1);
+          break;
+        }
+        case 'status': {
+          const diagnostics = sdk.getDiagnostics();
+          console.log(JSON.stringify(diagnostics, null, 2));
+          break;
+        }
+        default:
+          console.log('Usage: npx lint-tools-sdk [command]');
+          console.log('Commands:');
+          console.log('  init          Initialize the lint tools in your project');
+          console.log('  lint          Run eslint on your project');
+          console.log('  lint:fix      Run eslint with --fix on your project');
+          console.log('  lint:staged   Run eslint on staged files only');
+          console.log('  commitlint    Lint a commit message');
+          console.log('  status        Show diagnostic information');
+          break;
+      }
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    }
+  })();
+}